<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE BangPatterns        #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE CPP                 #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# LANGUAGE FlexibleContexts    #-}</span><span>
</span><span id="line-4"></span><span class="hs-pragma">{-# LANGUAGE GADTs               #-}</span><span>
</span><span id="line-5"></span><span class="hs-pragma">{-# LANGUAGE RankNTypes          #-}</span><span>
</span><span id="line-6"></span><span class="hs-pragma">{-# LANGUAGE ScopedTypeVariables #-}</span><span>
</span><span id="line-7"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Distribution.Parsec</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-8"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier">Parsec</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-9"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier">ParsecParser</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-10"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#runParsecParser"><span class="hs-identifier">runParsecParser</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-11"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#runParsecParser%27"><span class="hs-identifier">runParsecParser'</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-12"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#simpleParsec"><span class="hs-identifier">simpleParsec</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-13"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#simpleParsecBS"><span class="hs-identifier">simpleParsecBS</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-14"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#simpleParsec%27"><span class="hs-identifier">simpleParsec'</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-15"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#simpleParsecW%27"><span class="hs-identifier">simpleParsecW'</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-16"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#lexemeParsec"><span class="hs-identifier">lexemeParsec</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-17"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#eitherParsec"><span class="hs-identifier">eitherParsec</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-18"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#explicitEitherParsec"><span class="hs-identifier">explicitEitherParsec</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-19"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#explicitEitherParsec%27"><span class="hs-identifier">explicitEitherParsec'</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-20"></span><span>    </span><span class="annot"><span class="hs-comment">-- * CabalParsing and diagnostics</span></span><span>
</span><span id="line-21"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier">CabalParsing</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-22"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Warnings</span></span><span>
</span><span id="line-23"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Warning.html#PWarnType"><span class="hs-identifier">PWarnType</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-24"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Warning.html#PWarning"><span class="hs-identifier">PWarning</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-25"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Warning.html#showPWarning"><span class="hs-identifier">showPWarning</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-26"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Errors</span></span><span>
</span><span id="line-27"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Error.html#PError"><span class="hs-identifier">PError</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-28"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Error.html#showPError"><span class="hs-identifier">showPError</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-29"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Position</span></span><span>
</span><span id="line-30"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Position.html#Position"><span class="hs-identifier">Position</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-31"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Position.html#incPos"><span class="hs-identifier">incPos</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-32"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Position.html#retPos"><span class="hs-identifier">retPos</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-33"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Position.html#showPos"><span class="hs-identifier">showPos</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-34"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.Position.html#zeroPos"><span class="hs-identifier">zeroPos</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-35"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Utilities</span></span><span>
</span><span id="line-36"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecToken"><span class="hs-identifier">parsecToken</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-37"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecToken%27"><span class="hs-identifier">parsecToken'</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-38"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecFilePath"><span class="hs-identifier">parsecFilePath</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-39"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecQuoted"><span class="hs-identifier">parsecQuoted</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-40"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecMaybeQuoted"><span class="hs-identifier">parsecMaybeQuoted</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-41"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecCommaList"><span class="hs-identifier">parsecCommaList</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-42"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecCommaNonEmpty"><span class="hs-identifier">parsecCommaNonEmpty</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-43"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecLeadingCommaList"><span class="hs-identifier">parsecLeadingCommaList</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-44"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecLeadingCommaNonEmpty"><span class="hs-identifier">parsecLeadingCommaNonEmpty</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-45"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecOptCommaList"><span class="hs-identifier">parsecOptCommaList</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-46"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecLeadingOptCommaList"><span class="hs-identifier">parsecLeadingOptCommaList</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-47"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecStandard"><span class="hs-identifier">parsecStandard</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-48"></span><span>    </span><span class="annot"><a href="Distribution.Parsec.html#parsecUnqualComponentName"><span class="hs-identifier">parsecUnqualComponentName</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-49"></span><span>    </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-50"></span><span>
</span><span id="line-51"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.html#"><span class="hs-identifier">Data.ByteString</span></a></span><span>                     </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier">ByteString</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-52"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Char.html#"><span class="hs-identifier">Data.Char</span></a></span><span>                           </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Char.html#digitToInt"><span class="hs-identifier">digitToInt</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Show.html#intToDigit"><span class="hs-identifier">intToDigit</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-53"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.List.html#"><span class="hs-identifier">Data.List</span></a></span><span>                           </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.OldList.html#transpose"><span class="hs-identifier">transpose</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-54"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.CabalSpecVersion.html"><span class="hs-identifier">Distribution.CabalSpecVersion</span></a></span><span>
</span><span id="line-55"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Compat.Prelude.html"><span class="hs-identifier">Distribution.Compat.Prelude</span></a></span><span>
</span><span id="line-56"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Parsec.Error.html"><span class="hs-identifier">Distribution.Parsec.Error</span></a></span><span>           </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Parsec.Error.html#PError"><span class="hs-identifier">PError</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.Error.html#showPError"><span class="hs-identifier">showPError</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-57"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html"><span class="hs-identifier">Distribution.Parsec.FieldLineStream</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html#FieldLineStream"><span class="hs-identifier">FieldLineStream</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromBS"><span class="hs-identifier">fieldLineStreamFromBS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromString"><span class="hs-identifier">fieldLineStreamFromString</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-58"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Parsec.Position.html"><span class="hs-identifier">Distribution.Parsec.Position</span></a></span><span>        </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Parsec.Position.html#Position"><span class="hs-identifier">Position</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.Position.html#incPos"><span class="hs-identifier">incPos</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.Position.html#retPos"><span class="hs-identifier">retPos</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.Position.html#showPos"><span class="hs-identifier">showPos</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.Position.html#zeroPos"><span class="hs-identifier">zeroPos</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-59"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Parsec.Warning.html"><span class="hs-identifier">Distribution.Parsec.Warning</span></a></span><span>         </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Parsec.Warning.html#PWarnType"><span class="hs-identifier">PWarnType</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.Warning.html#PWarning"><span class="hs-identifier">PWarning</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.Warning.html#showPWarning"><span class="hs-identifier">showPWarning</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-60"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Numeric.html#"><span class="hs-identifier">Numeric</span></a></span><span>                             </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Numeric.html#showIntAtBase"><span class="hs-identifier">showIntAtBase</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-61"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html"><span class="hs-identifier">Distribution.Compat.CharParsing</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">P</span></span><span>
</span><span id="line-64"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Distribution.Compat.DList.html"><span class="hs-identifier">Distribution.Compat.DList</span></a></span><span>       </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">DList</span></span><span>
</span><span id="line-65"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Distribution.Compat.MonadFail.html"><span class="hs-identifier">Distribution.Compat.MonadFail</span></a></span><span>   </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Fail</span></span><span>
</span><span id="line-66"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../parsec/src/Text.Parsec.html#"><span class="hs-identifier">Text.Parsec</span></a></span><span>                     </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Parsec</span></span><span>
</span><span id="line-67"></span><span>
</span><span id="line-68"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-69"></span><span class="hs-comment">-- Class</span><span>
</span><span id="line-70"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-71"></span><span>
</span><span id="line-72"></span><span class="hs-comment">-- | Class for parsing with @parsec@. Mainly used for @.cabal@ file fields.</span><span>
</span><span id="line-73"></span><span class="hs-comment">--</span><span>
</span><span id="line-74"></span><span class="hs-comment">-- For parsing @.cabal@ like file structure, see &quot;Distribution.Fields&quot;.</span><span>
</span><span id="line-75"></span><span class="hs-comment">--</span><span>
</span><span id="line-76"></span><span class="hs-keyword">class</span><span> </span><span id="Parsec"><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-var">Parsec</span></a></span></span><span> </span><span id="local-6989586621679629626"><span class="annot"><a href="#local-6989586621679629626"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-77"></span><span>    </span><span id="local-6989586621679629625"><span id="parsec"><span class="annot"><a href="Distribution.Parsec.html#parsec"><span class="hs-identifier hs-type">parsec</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629625"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629625"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629626"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-78"></span><span>
</span><span id="line-79"></span><span class="hs-comment">-- | Parsing class which</span><span>
</span><span id="line-80"></span><span class="hs-comment">--</span><span>
</span><span id="line-81"></span><span class="hs-comment">-- * can report Cabal parser warnings.</span><span>
</span><span id="line-82"></span><span class="hs-comment">--</span><span>
</span><span id="line-83"></span><span class="hs-comment">-- * knows @cabal-version@ we work with</span><span>
</span><span id="line-84"></span><span class="hs-comment">--</span><span>
</span><span id="line-85"></span><span class="hs-keyword">class</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">P.CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629639"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629639"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.Fail.html#MonadFail"><span class="hs-identifier hs-type">Fail.MonadFail</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629639"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span id="CabalParsing"><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-var">CabalParsing</span></a></span></span><span> </span><span id="local-6989586621679629639"><span class="annot"><a href="#local-6989586621679629639"><span class="hs-identifier hs-type">m</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-86"></span><span>    </span><span id="parsecWarning"><span class="annot"><a href="Distribution.Parsec.html#parsecWarning"><span class="hs-identifier hs-type">parsecWarning</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.Warning.html#PWarnType"><span class="hs-identifier hs-type">PWarnType</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629639"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-87"></span><span>
</span><span id="line-88"></span><span>    </span><span id="parsecHaskellString"><span class="annot"><a href="Distribution.Parsec.html#parsecHaskellString"><span class="hs-identifier hs-type">parsecHaskellString</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629639"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-89"></span><span>    </span><span id="local-6989586621679629318"><span class="annot"><a href="Distribution.Parsec.html#parsecHaskellString"><span class="hs-identifier hs-var hs-var">parsecHaskellString</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m String
forall (m :: * -&gt; *). CharParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#stringLiteral"><span class="hs-identifier hs-var">stringLiteral</span></a></span></span><span>
</span><span id="line-90"></span><span>
</span><span id="line-91"></span><span>    </span><span id="askCabalSpecVersion"><span class="annot"><a href="Distribution.Parsec.html#askCabalSpecVersion"><span class="hs-identifier hs-type">askCabalSpecVersion</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629639"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Distribution.CabalSpecVersion.html#CabalSpecVersion"><span class="hs-identifier hs-type">CabalSpecVersion</span></a></span><span>
</span><span id="line-92"></span><span>
</span><span id="line-93"></span><span class="hs-comment">-- | 'parsec' /could/ consume trailing spaces, this function /will/ consume.</span><span>
</span><span id="line-94"></span><span id="local-6989586621679629635"><span id="local-6989586621679629636"><span class="annot"><a href="Distribution.Parsec.html#lexemeParsec"><span class="hs-identifier hs-type">lexemeParsec</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629636"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629635"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629636"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629635"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-95"></span><span id="lexemeParsec"><span class="annot"><span class="annottext">lexemeParsec :: forall (m :: * -&gt; *) a. (CabalParsing m, Parsec a) =&gt; m a
</span><a href="Distribution.Parsec.html#lexemeParsec"><span class="hs-identifier hs-var hs-var">lexemeParsec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
forall a (m :: * -&gt; *). (Parsec a, CabalParsing m) =&gt; m a
</span><a href="Distribution.Parsec.html#parsec"><span class="hs-identifier hs-var">parsec</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span>
</span><span id="line-96"></span><span>
</span><span id="line-97"></span><span class="hs-keyword">newtype</span><span> </span><span id="ParsecParser"><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-var">ParsecParser</span></a></span></span><span> </span><span id="local-6989586621679629620"><span class="annot"><a href="#local-6989586621679629620"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="PP"><span class="annot"><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span></span><span> </span><span class="hs-special">{</span><span> </span><span id="unPP"><span class="annot"><span class="annottext">forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span></span><span>
</span><span id="line-98"></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.CabalSpecVersion.html#CabalSpecVersion"><span class="hs-identifier hs-type">CabalSpecVersion</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../parsec/src/Text.Parsec.Prim.html#Parsec"><span class="hs-identifier hs-type">Parsec.Parsec</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html#FieldLineStream"><span class="hs-identifier hs-type">FieldLineStream</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Distribution.Parsec.Warning.html#PWarning"><span class="hs-identifier hs-type">PWarning</span></a></span><span class="hs-special">]</span><span> </span><span class="annot"><a href="#local-6989586621679629620"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-99"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-100"></span><span>
</span><span id="line-101"></span><span id="local-6989586621679629614"><span class="annot"><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-type">liftParsec</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../parsec/src/Text.Parsec.Prim.html#Parsec"><span class="hs-identifier hs-type">Parsec.Parsec</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html#FieldLineStream"><span class="hs-identifier hs-type">FieldLineStream</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Distribution.Parsec.Warning.html#PWarning"><span class="hs-identifier hs-type">PWarning</span></a></span><span class="hs-special">]</span><span> </span><span class="annot"><a href="#local-6989586621679629614"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629614"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-102"></span><span id="liftParsec"><span class="annot"><span class="annottext">liftParsec :: forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var hs-var">liftParsec</span></a></span></span><span> </span><span id="local-6989586621679629295"><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
</span><a href="#local-6989586621679629295"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
 -&gt; ParsecParser a)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="annot"><span class="annottext">CabalSpecVersion
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
</span><a href="#local-6989586621679629295"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-103"></span><span>
</span><span id="line-104"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Functor"><span class="hs-identifier hs-type">Functor</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-105"></span><span>    </span><span id="local-6989586621679629288"><span class="annot"><span class="annottext">fmap :: forall a b. (a -&gt; b) -&gt; ParsecParser a -&gt; ParsecParser b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var hs-var hs-var hs-var">fmap</span></a></span></span><span> </span><span id="local-6989586621679629287"><span class="annot"><span class="annottext">a -&gt; b
</span><a href="#local-6989586621679629287"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621679629286"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629286"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
 -&gt; ParsecParser b)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629285"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629285"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">(a -&gt; b)
-&gt; ParsecT FieldLineStream [PWarning] Identity a
-&gt; Parsec FieldLineStream [PWarning] b
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; b
</span><a href="#local-6989586621679629287"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629286"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629285"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-106"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-pragma hs-type">fmap</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-107"></span><span>
</span><span id="line-108"></span><span>    </span><span id="local-6989586621679629283"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679629283"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679629282"><span class="annot"><span class="annottext">&lt;$ :: forall a b. a -&gt; ParsecParser b -&gt; ParsecParser a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;$</span></a></span></span><span> </span><span id="local-6989586621679629280"><span class="annot"><span class="annottext">ParsecParser b
</span><a href="#local-6989586621679629280"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
 -&gt; ParsecParser a)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629279"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629279"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679629283"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a
-&gt; ParsecT FieldLineStream [PWarning] Identity b
-&gt; Parsec FieldLineStream [PWarning] a
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser b
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity b
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser b
</span><a href="#local-6989586621679629280"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629279"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-109"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;$</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-110"></span><span>
</span><span id="line-111"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679629273"><span class="annot"><a href="../../base/src/GHC.Base.html#Applicative"><span class="hs-identifier hs-type">Applicative</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-112"></span><span>    </span><span id="local-6989586621679629267"><span class="annot"><span class="annottext">pure :: forall a. a -&gt; ParsecParser a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var hs-var hs-var hs-var">pure</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">(Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a)
-&gt; (a -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; a
-&gt; ParsecParser a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Parsec FieldLineStream [PWarning] a
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span>
</span><span id="line-113"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#pure"><span class="hs-pragma hs-type">pure</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-114"></span><span>
</span><span id="line-115"></span><span>    </span><span id="local-6989586621679629264"><span class="annot"><span class="annottext">ParsecParser (a -&gt; b)
</span><a href="#local-6989586621679629264"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621679629263"><span class="annot"><span class="annottext">&lt;*&gt; :: forall a b.
ParsecParser (a -&gt; b) -&gt; ParsecParser a -&gt; ParsecParser b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;*&gt;</span></a></span></span><span> </span><span id="local-6989586621679629262"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629262"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
 -&gt; ParsecParser b)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629261"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629261"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecParser (a -&gt; b)
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] (a -&gt; b)
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser (a -&gt; b)
</span><a href="#local-6989586621679629264"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629261"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] (a -&gt; b)
-&gt; ParsecT FieldLineStream [PWarning] Identity a
-&gt; Parsec FieldLineStream [PWarning] b
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629262"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629261"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-116"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;*&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-117"></span><span>    </span><span id="local-6989586621679629259"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629259"><span class="hs-identifier hs-var">f</span></a></span></span><span>  </span><span id="local-6989586621679629258"><span class="annot"><span class="annottext">*&gt; :: forall a b. ParsecParser a -&gt; ParsecParser b -&gt; ParsecParser b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">*&gt;</span></a></span></span><span> </span><span id="local-6989586621679629257"><span class="annot"><span class="annottext">ParsecParser b
</span><a href="#local-6989586621679629257"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
 -&gt; ParsecParser b)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629256"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629256"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629259"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629256"><span class="hs-identifier hs-var">v</span></a></span><span>  </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; Parsec FieldLineStream [PWarning] b
-&gt; Parsec FieldLineStream [PWarning] b
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser b
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser b
</span><a href="#local-6989586621679629257"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629256"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-118"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">*&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-119"></span><span>    </span><span id="local-6989586621679629254"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629254"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621679629253"><span class="annot"><span class="annottext">&lt;* :: forall a b. ParsecParser a -&gt; ParsecParser b -&gt; ParsecParser a
</span><a href="#local-6989586621679629253"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;*</span></a></span></span><span>  </span><span id="local-6989586621679629252"><span class="annot"><span class="annottext">ParsecParser b
</span><a href="#local-6989586621679629252"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
 -&gt; ParsecParser a)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629251"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629251"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629254"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629251"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; ParsecT FieldLineStream [PWarning] Identity b
-&gt; Parsec FieldLineStream [PWarning] a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span>  </span><span class="annot"><span class="annottext">ParsecParser b
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity b
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser b
</span><a href="#local-6989586621679629252"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629251"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-120"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;*</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-121"></span><span>
</span><span id="line-122"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-123"></span><span>    </span><span id="local-6989586621679629240"><span class="annot"><span class="annottext">empty :: forall a. ParsecParser a
</span><a href="../../base/src/GHC.Base.html#empty"><span class="hs-identifier hs-var hs-var hs-var hs-var">empty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a
</span><a href="../../base/src/GHC.Base.html#empty"><span class="hs-identifier hs-var">empty</span></a></span><span>
</span><span id="line-124"></span><span>
</span><span id="line-125"></span><span>    </span><span id="local-6989586621679629237"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629237"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621679629236"><span class="annot"><span class="annottext">&lt;|&gt; :: forall a. ParsecParser a -&gt; ParsecParser a -&gt; ParsecParser a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;|&gt;</span></a></span></span><span> </span><span id="local-6989586621679629234"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629234"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
 -&gt; ParsecParser a)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629233"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629233"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629237"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629233"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; Parsec FieldLineStream [PWarning] a
-&gt; Parsec FieldLineStream [PWarning] a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629234"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629233"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-126"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;|&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-127"></span><span>
</span><span id="line-128"></span><span>    </span><span id="local-6989586621679629231"><span class="annot"><span class="annottext">many :: forall a. ParsecParser a -&gt; ParsecParser [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var hs-var hs-var hs-var">many</span></a></span></span><span> </span><span id="local-6989586621679629229"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629229"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] [a])
-&gt; ParsecParser [a]
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] [a])
 -&gt; ParsecParser [a])
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] [a])
-&gt; ParsecParser [a]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629228"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629228"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecT FieldLineStream [PWarning] Identity a
-&gt; Parsec FieldLineStream [PWarning] [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629229"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629228"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-129"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#many"><span class="hs-pragma hs-type">many</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-130"></span><span>
</span><span id="line-131"></span><span>    </span><span id="local-6989586621679629226"><span class="annot"><span class="annottext">some :: forall a. ParsecParser a -&gt; ParsecParser [a]
</span><a href="../../base/src/GHC.Base.html#some"><span class="hs-identifier hs-var hs-var hs-var hs-var">some</span></a></span></span><span> </span><span id="local-6989586621679629224"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629224"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] [a])
-&gt; ParsecParser [a]
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] [a])
 -&gt; ParsecParser [a])
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] [a])
-&gt; ParsecParser [a]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629223"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629223"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecT FieldLineStream [PWarning] Identity a
-&gt; Parsec FieldLineStream [PWarning] [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#some"><span class="hs-identifier hs-var">some</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629224"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629223"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-132"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#some"><span class="hs-pragma hs-type">some</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-133"></span><span>
</span><span id="line-134"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monad"><span class="hs-identifier hs-type">Monad</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-135"></span><span>    </span><span id="local-6989586621679629214"><span class="annot"><span class="annottext">return :: forall a. a -&gt; ParsecParser a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var hs-var hs-var hs-var">return</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; ParsecParser a
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span>
</span><span id="line-136"></span><span>
</span><span id="line-137"></span><span>    </span><span id="local-6989586621679629211"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629211"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679629210"><span class="annot"><span class="annottext">&gt;&gt;= :: forall a b.
ParsecParser a -&gt; (a -&gt; ParsecParser b) -&gt; ParsecParser b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var hs-var hs-var hs-var">&gt;&gt;=</span></a></span></span><span> </span><span id="local-6989586621679629209"><span class="annot"><span class="annottext">a -&gt; ParsecParser b
</span><a href="#local-6989586621679629209"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
 -&gt; ParsecParser b)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; ParsecParser b
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629208"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629208"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629211"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629208"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; (a -&gt; Parsec FieldLineStream [PWarning] b)
-&gt; Parsec FieldLineStream [PWarning] b
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629207"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679629207"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecParser b
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] b
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; ParsecParser b
</span><a href="#local-6989586621679629209"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679629207"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629208"><span class="hs-identifier hs-var">v</span></a></span><span>
</span><span id="line-138"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&gt;&gt;=</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-139"></span><span>    </span><span id="local-6989586621679629205"><span class="annot"><span class="annottext">&gt;&gt; :: forall a b. ParsecParser a -&gt; ParsecParser b -&gt; ParsecParser b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">(&gt;&gt;)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; ParsecParser b -&gt; ParsecParser b
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">(*&gt;)</span></a></span><span>
</span><span id="line-140"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&gt;&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span class="hs-cpp">

#if !(MIN_VERSION_base(4,13,0))
</span><span>    </span><span class="hs-identifier">fail</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">Fail.fail</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-146"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-147"></span><span>    </span><span id="local-6989586621679629195"><span class="annot"><span class="annottext">mzero :: forall a. ParsecParser a
</span><a href="../../base/src/GHC.Base.html#mzero"><span class="hs-identifier hs-var hs-var hs-var hs-var">mzero</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecParser a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a
</span><a href="../../base/src/GHC.Base.html#empty"><span class="hs-identifier hs-var">empty</span></a></span><span>
</span><span id="line-148"></span><span>    </span><span id="local-6989586621679629192"><span class="annot"><span class="annottext">mplus :: forall a. ParsecParser a -&gt; ParsecParser a -&gt; ParsecParser a
</span><a href="../../base/src/GHC.Base.html#mplus"><span class="hs-identifier hs-var hs-var hs-var hs-var">mplus</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; ParsecParser a -&gt; ParsecParser a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">(&lt;|&gt;)</span></a></span><span>
</span><span id="line-149"></span><span>
</span><span id="line-150"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.Fail.html#MonadFail"><span class="hs-identifier hs-type">Fail.MonadFail</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-151"></span><span>    </span><span id="local-6989586621679629183"><span class="annot"><span class="annottext">fail :: forall a. String -&gt; ParsecParser a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var hs-var hs-var hs-var">fail</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecParser a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">P.unexpected</span></a></span><span>
</span><span id="line-152"></span><span>
</span><span id="line-153"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">P.Parsing</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-154"></span><span>    </span><span id="local-6989586621679629163"><span class="annot"><span class="annottext">try :: forall a. ParsecParser a -&gt; ParsecParser a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span id="local-6989586621679629161"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629161"><span class="hs-identifier hs-var">p</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
 -&gt; ParsecParser a)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629160"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629160"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; Parsec FieldLineStream [PWarning] a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">P.try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629161"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629160"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-155"></span><span>    </span><span id="local-6989586621679629155"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629155"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679629154"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. ParsecParser a -&gt; String -&gt; ParsecParser a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679629152"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679629152"><span class="hs-identifier hs-var">d</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
 -&gt; ParsecParser a)
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629151"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629151"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629155"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629151"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; String -&gt; Parsec FieldLineStream [PWarning] a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679629152"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-156"></span><span>    </span><span id="local-6989586621679629146"><span class="annot"><span class="annottext">skipMany :: forall a. ParsecParser a -&gt; ParsecParser ()
</span><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-var hs-var hs-var hs-var">skipMany</span></a></span></span><span> </span><span id="local-6989586621679629144"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629144"><span class="hs-identifier hs-var">p</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
-&gt; ParsecParser ()
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
 -&gt; ParsecParser ())
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
-&gt; ParsecParser ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629143"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629143"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecT FieldLineStream [PWarning] Identity a
-&gt; Parsec FieldLineStream [PWarning] ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-var">P.skipMany</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629144"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629143"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-157"></span><span>    </span><span id="local-6989586621679629138"><span class="annot"><span class="annottext">skipSome :: forall a. ParsecParser a -&gt; ParsecParser ()
</span><a href="Distribution.Compat.Parsing.html#skipSome"><span class="hs-identifier hs-var hs-var hs-var hs-var">skipSome</span></a></span></span><span> </span><span id="local-6989586621679629136"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629136"><span class="hs-identifier hs-var">p</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
-&gt; ParsecParser ()
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
 -&gt; ParsecParser ())
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
-&gt; ParsecParser ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629135"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629135"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecT FieldLineStream [PWarning] Identity a
-&gt; Parsec FieldLineStream [PWarning] ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipSome"><span class="hs-identifier hs-var">P.skipSome</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629136"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629135"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-158"></span><span>    </span><span id="local-6989586621679629130"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; ParsecParser a
</span><a href="#local-6989586621679629130"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">(Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a)
-&gt; (String -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; String
-&gt; ParsecParser a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Parsec FieldLineStream [PWarning] a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">P.unexpected</span></a></span><span>
</span><span id="line-159"></span><span>    </span><span id="local-6989586621679629125"><span class="annot"><span class="annottext">eof :: ParsecParser ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span>             </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] () -&gt; ParsecParser ()
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">P.eof</span></a></span><span>
</span><span id="line-160"></span><span>    </span><span id="local-6989586621679629117"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; ParsecParser a -&gt; ParsecParser ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span id="local-6989586621679629115"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629115"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
-&gt; ParsecParser ()
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">((CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
 -&gt; ParsecParser ())
-&gt; (CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] ())
-&gt; ParsecParser ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679629114"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629114"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecT FieldLineStream [PWarning] Identity a
-&gt; Parsec FieldLineStream [PWarning] ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">P.notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion
-&gt; ParsecT FieldLineStream [PWarning] Identity a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629115"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629114"><span class="hs-identifier hs-var">v</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-161"></span><span>
</span><span id="line-162"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679629105"><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">P.CharParsing</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-163"></span><span>    </span><span id="local-6989586621679629099"><span class="annot"><span class="annottext">satisfy :: (Char -&gt; Bool) -&gt; ParsecParser Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var hs-var hs-var hs-var">satisfy</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] Char -&gt; ParsecParser Char
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">(Parsec FieldLineStream [PWarning] Char -&gt; ParsecParser Char)
-&gt; ((Char -&gt; Bool) -&gt; Parsec FieldLineStream [PWarning] Char)
-&gt; (Char -&gt; Bool)
-&gt; ParsecParser Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; Parsec FieldLineStream [PWarning] Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">P.satisfy</span></a></span><span>
</span><span id="line-164"></span><span>    </span><span id="local-6989586621679629094"><span class="annot"><span class="annottext">char :: Char -&gt; ParsecParser Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var hs-var hs-var hs-var">char</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] Char -&gt; ParsecParser Char
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">(Parsec FieldLineStream [PWarning] Char -&gt; ParsecParser Char)
-&gt; (Char -&gt; Parsec FieldLineStream [PWarning] Char)
-&gt; Char
-&gt; ParsecParser Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Parsec FieldLineStream [PWarning] Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span>
</span><span id="line-165"></span><span>    </span><span id="local-6989586621679629089"><span class="annot"><span class="annottext">notChar :: Char -&gt; ParsecParser Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var hs-var hs-var hs-var">notChar</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] Char -&gt; ParsecParser Char
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">(Parsec FieldLineStream [PWarning] Char -&gt; ParsecParser Char)
-&gt; (Char -&gt; Parsec FieldLineStream [PWarning] Char)
-&gt; Char
-&gt; ParsecParser Char
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Parsec FieldLineStream [PWarning] Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#notChar"><span class="hs-identifier hs-var">P.notChar</span></a></span><span>
</span><span id="line-166"></span><span>    </span><span id="local-6989586621679629084"><span class="annot"><span class="annottext">anyChar :: ParsecParser Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var hs-var hs-var hs-var">anyChar</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] Char -&gt; ParsecParser Char
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#anyChar"><span class="hs-identifier hs-var">P.anyChar</span></a></span><span>
</span><span id="line-167"></span><span>    </span><span id="local-6989586621679629079"><span class="annot"><span class="annottext">string :: String -&gt; ParsecParser String
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var hs-var hs-var hs-var">string</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] String -&gt; ParsecParser String
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">(Parsec FieldLineStream [PWarning] String -&gt; ParsecParser String)
-&gt; (String -&gt; Parsec FieldLineStream [PWarning] String)
-&gt; String
-&gt; ParsecParser String
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Parsec FieldLineStream [PWarning] String
forall (m :: * -&gt; *). CharParsing m =&gt; String -&gt; m String
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">P.string</span></a></span><span>
</span><span id="line-168"></span><span>
</span><span id="line-169"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679629069"><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-170"></span><span>    </span><span id="local-6989586621679629063"><span class="annot"><span class="annottext">parsecWarning :: PWarnType -&gt; String -&gt; ParsecParser ()
</span><a href="#local-6989586621679629063"><span class="hs-identifier hs-var hs-var hs-var hs-var">parsecWarning</span></a></span></span><span> </span><span id="local-6989586621679629062"><span class="annot"><span class="annottext">PWarnType
</span><a href="#local-6989586621679629062"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span id="local-6989586621679629061"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679629061"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] () -&gt; ParsecParser ()
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">(Parsec FieldLineStream [PWarning] () -&gt; ParsecParser ())
-&gt; Parsec FieldLineStream [PWarning] () -&gt; ParsecParser ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-171"></span><span>        </span><span id="local-6989586621679629060"><span class="annot"><span class="annottext">SourcePos
</span><a href="#local-6989586621679629060"><span class="hs-identifier hs-var">spos</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT FieldLineStream [PWarning] Identity SourcePos
forall (m :: * -&gt; *) s u. Monad m =&gt; ParsecT s u m SourcePos
</span><a href="../../parsec/src/Text.Parsec.Prim.html#getPosition"><span class="hs-identifier hs-var">Parsec.getPosition</span></a></span><span>
</span><span id="line-172"></span><span>        </span><span class="annot"><span class="annottext">([PWarning] -&gt; [PWarning]) -&gt; Parsec FieldLineStream [PWarning] ()
forall (m :: * -&gt; *) u s. Monad m =&gt; (u -&gt; u) -&gt; ParsecT s u m ()
</span><a href="../../parsec/src/Text.Parsec.Prim.html#modifyState"><span class="hs-identifier hs-var">Parsec.modifyState</span></a></span><span>
</span><span id="line-173"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">PWarnType -&gt; Position -&gt; String -&gt; PWarning
</span><a href="Distribution.Parsec.Warning.html#PWarning"><span class="hs-identifier hs-var">PWarning</span></a></span><span> </span><span class="annot"><span class="annottext">PWarnType
</span><a href="#local-6989586621679629062"><span class="hs-identifier hs-var">t</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Position
</span><a href="Distribution.Parsec.Position.html#Position"><span class="hs-identifier hs-var">Position</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourcePos -&gt; Int
</span><a href="../../parsec/src/Text.Parsec.Pos.html#sourceLine"><span class="hs-identifier hs-var">Parsec.sourceLine</span></a></span><span> </span><span class="annot"><span class="annottext">SourcePos
</span><a href="#local-6989586621679629060"><span class="hs-identifier hs-var">spos</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourcePos -&gt; Int
</span><a href="../../parsec/src/Text.Parsec.Pos.html#sourceColumn"><span class="hs-identifier hs-var">Parsec.sourceColumn</span></a></span><span> </span><span class="annot"><span class="annottext">SourcePos
</span><a href="#local-6989586621679629060"><span class="hs-identifier hs-var">spos</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679629061"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">PWarning -&gt; [PWarning] -&gt; [PWarning]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="hs-special">)</span><span>
</span><span id="line-174"></span><span>    </span><span id="local-6989586621679629052"><span class="annot"><span class="annottext">askCabalSpecVersion :: ParsecParser CabalSpecVersion
</span><a href="#local-6989586621679629052"><span class="hs-identifier hs-var hs-var hs-var hs-var">askCabalSpecVersion</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(CabalSpecVersion
 -&gt; Parsec FieldLineStream [PWarning] CabalSpecVersion)
-&gt; ParsecParser CabalSpecVersion
forall a.
(CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a)
-&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#PP"><span class="hs-identifier hs-var">PP</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
-&gt; Parsec FieldLineStream [PWarning] CabalSpecVersion
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span>
</span><span id="line-175"></span><span>
</span><span id="line-176"></span><span class="hs-comment">-- | Parse a 'String' with 'lexemeParsec'.</span><span>
</span><span id="line-177"></span><span id="local-6989586621679629511"><span class="annot"><a href="Distribution.Parsec.html#simpleParsec"><span class="hs-identifier hs-type">simpleParsec</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629511"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629511"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-178"></span><span id="simpleParsec"><span class="annot"><span class="annottext">simpleParsec :: forall a. Parsec a =&gt; String -&gt; Maybe a
</span><a href="Distribution.Parsec.html#simpleParsec"><span class="hs-identifier hs-var hs-var">simpleParsec</span></a></span></span><span>
</span><span id="line-179"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ParseError -&gt; Maybe a)
-&gt; (a -&gt; Maybe a) -&gt; Either ParseError a -&gt; Maybe a
forall a c b. (a -&gt; c) -&gt; (b -&gt; c) -&gt; Either a b -&gt; c
</span><a href="../../base/src/Data.Either.html#either"><span class="hs-identifier hs-var">either</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe a -&gt; ParseError -&gt; Maybe a
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span>
</span><span id="line-180"></span><span>    </span><span class="annot"><span class="annottext">(Either ParseError a -&gt; Maybe a)
-&gt; (String -&gt; Either ParseError a) -&gt; String -&gt; Maybe a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
forall a.
ParsecParser a -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser"><span class="hs-identifier hs-var">runParsecParser</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
forall (m :: * -&gt; *) a. (CabalParsing m, Parsec a) =&gt; m a
</span><a href="Distribution.Parsec.html#lexemeParsec"><span class="hs-identifier hs-var">lexemeParsec</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;simpleParsec&gt;&quot;</span></span><span>
</span><span id="line-181"></span><span>    </span><span class="annot"><span class="annottext">(FieldLineStream -&gt; Either ParseError a)
-&gt; (String -&gt; FieldLineStream) -&gt; String -&gt; Either ParseError a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; FieldLineStream
</span><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromString"><span class="hs-identifier hs-var">fieldLineStreamFromString</span></a></span><span>
</span><span id="line-182"></span><span>
</span><span id="line-183"></span><span class="hs-comment">-- | Like 'simpleParsec' but for 'ByteString'</span><span>
</span><span id="line-184"></span><span id="local-6989586621679629502"><span class="annot"><a href="Distribution.Parsec.html#simpleParsecBS"><span class="hs-identifier hs-type">simpleParsecBS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629502"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629502"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-185"></span><span id="simpleParsecBS"><span class="annot"><span class="annottext">simpleParsecBS :: forall a. Parsec a =&gt; ByteString -&gt; Maybe a
</span><a href="Distribution.Parsec.html#simpleParsecBS"><span class="hs-identifier hs-var hs-var">simpleParsecBS</span></a></span></span><span>
</span><span id="line-186"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ParseError -&gt; Maybe a)
-&gt; (a -&gt; Maybe a) -&gt; Either ParseError a -&gt; Maybe a
forall a c b. (a -&gt; c) -&gt; (b -&gt; c) -&gt; Either a b -&gt; c
</span><a href="../../base/src/Data.Either.html#either"><span class="hs-identifier hs-var">either</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe a -&gt; ParseError -&gt; Maybe a
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span>
</span><span id="line-187"></span><span>    </span><span class="annot"><span class="annottext">(Either ParseError a -&gt; Maybe a)
-&gt; (ByteString -&gt; Either ParseError a) -&gt; ByteString -&gt; Maybe a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
forall a.
ParsecParser a -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser"><span class="hs-identifier hs-var">runParsecParser</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
forall (m :: * -&gt; *) a. (CabalParsing m, Parsec a) =&gt; m a
</span><a href="Distribution.Parsec.html#lexemeParsec"><span class="hs-identifier hs-var">lexemeParsec</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;simpleParsec&gt;&quot;</span></span><span>
</span><span id="line-188"></span><span>    </span><span class="annot"><span class="annottext">(FieldLineStream -&gt; Either ParseError a)
-&gt; (ByteString -&gt; FieldLineStream)
-&gt; ByteString
-&gt; Either ParseError a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; FieldLineStream
</span><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromBS"><span class="hs-identifier hs-var">fieldLineStreamFromBS</span></a></span><span>
</span><span id="line-189"></span><span>
</span><span id="line-190"></span><span class="hs-comment">-- | Parse a 'String' with 'lexemeParsec' using specific 'CabalSpecVersion'.</span><span>
</span><span id="line-191"></span><span class="hs-comment">--</span><span>
</span><span id="line-192"></span><span class="hs-comment">-- @since 3.4.0.0</span><span>
</span><span id="line-193"></span><span id="local-6989586621679629499"><span class="annot"><a href="Distribution.Parsec.html#simpleParsec%27"><span class="hs-identifier hs-type">simpleParsec'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629499"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.CabalSpecVersion.html#CabalSpecVersion"><span class="hs-identifier hs-type">CabalSpecVersion</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629499"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-194"></span><span id="simpleParsec%27"><span class="annot"><span class="annottext">simpleParsec' :: forall a. Parsec a =&gt; CabalSpecVersion -&gt; String -&gt; Maybe a
</span><a href="Distribution.Parsec.html#simpleParsec%27"><span class="hs-identifier hs-var hs-var">simpleParsec'</span></a></span></span><span> </span><span id="local-6989586621679629040"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629040"><span class="hs-identifier hs-var">spec</span></a></span></span><span>
</span><span id="line-195"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ParseError -&gt; Maybe a)
-&gt; (a -&gt; Maybe a) -&gt; Either ParseError a -&gt; Maybe a
forall a c b. (a -&gt; c) -&gt; (b -&gt; c) -&gt; Either a b -&gt; c
</span><a href="../../base/src/Data.Either.html#either"><span class="hs-identifier hs-var">either</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe a -&gt; ParseError -&gt; Maybe a
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span>
</span><span id="line-196"></span><span>    </span><span class="annot"><span class="annottext">(Either ParseError a -&gt; Maybe a)
-&gt; (String -&gt; Either ParseError a) -&gt; String -&gt; Maybe a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
forall a.
CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser%27"><span class="hs-identifier hs-var">runParsecParser'</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629040"><span class="hs-identifier hs-var">spec</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
forall (m :: * -&gt; *) a. (CabalParsing m, Parsec a) =&gt; m a
</span><a href="Distribution.Parsec.html#lexemeParsec"><span class="hs-identifier hs-var">lexemeParsec</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;simpleParsec&gt;&quot;</span></span><span>
</span><span id="line-197"></span><span>    </span><span class="annot"><span class="annottext">(FieldLineStream -&gt; Either ParseError a)
-&gt; (String -&gt; FieldLineStream) -&gt; String -&gt; Either ParseError a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; FieldLineStream
</span><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromString"><span class="hs-identifier hs-var">fieldLineStreamFromString</span></a></span><span>
</span><span id="line-198"></span><span>
</span><span id="line-199"></span><span class="hs-comment">-- | Parse a 'String' with 'lexemeParsec' using specific 'CabalSpecVersion'.</span><span>
</span><span id="line-200"></span><span class="hs-comment">-- Fail if there are any warnings.</span><span>
</span><span id="line-201"></span><span class="hs-comment">--</span><span>
</span><span id="line-202"></span><span class="hs-comment">-- @since 3.4.0.0</span><span>
</span><span id="line-203"></span><span id="local-6989586621679629039"><span class="annot"><a href="Distribution.Parsec.html#simpleParsecW%27"><span class="hs-identifier hs-type">simpleParsecW'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629039"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.CabalSpecVersion.html#CabalSpecVersion"><span class="hs-identifier hs-type">CabalSpecVersion</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629039"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-204"></span><span id="simpleParsecW%27"><span class="annot"><span class="annottext">simpleParsecW' :: forall a. Parsec a =&gt; CabalSpecVersion -&gt; String -&gt; Maybe a
</span><a href="Distribution.Parsec.html#simpleParsecW%27"><span class="hs-identifier hs-var hs-var">simpleParsecW'</span></a></span></span><span> </span><span id="local-6989586621679629030"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629030"><span class="hs-identifier hs-var">spec</span></a></span></span><span>
</span><span id="line-205"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ParseError -&gt; Maybe a)
-&gt; ((a, [PWarning]) -&gt; Maybe a)
-&gt; Either ParseError (a, [PWarning])
-&gt; Maybe a
forall a c b. (a -&gt; c) -&gt; (b -&gt; c) -&gt; Either a b -&gt; c
</span><a href="../../base/src/Data.Either.html#either"><span class="hs-identifier hs-var">either</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe a -&gt; ParseError -&gt; Maybe a
forall a b. a -&gt; b -&gt; a
</span><a href="../../base/src/GHC.Base.html#const"><span class="hs-identifier hs-var">const</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621679629029"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679629029"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679629028"><span class="annot"><span class="annottext">[PWarning]
</span><a href="#local-6989586621679629028"><span class="hs-identifier hs-var">ws</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">[PWarning] -&gt; Bool
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#null"><span class="hs-identifier hs-var">null</span></a></span><span> </span><span class="annot"><span class="annottext">[PWarning]
</span><a href="#local-6989586621679629028"><span class="hs-identifier hs-var">ws</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679629029"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-206"></span><span>    </span><span class="annot"><span class="annottext">(Either ParseError (a, [PWarning]) -&gt; Maybe a)
-&gt; (String -&gt; Either ParseError (a, [PWarning]))
-&gt; String
-&gt; Maybe a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
-&gt; ParsecParser (a, [PWarning])
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError (a, [PWarning])
forall a.
CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser%27"><span class="hs-identifier hs-var">runParsecParser'</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629030"><span class="hs-identifier hs-var">spec</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">,</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(a -&gt; [PWarning] -&gt; (a, [PWarning]))
-&gt; ParsecParser a -&gt; ParsecParser ([PWarning] -&gt; (a, [PWarning]))
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
forall (m :: * -&gt; *) a. (CabalParsing m, Parsec a) =&gt; m a
</span><a href="Distribution.Parsec.html#lexemeParsec"><span class="hs-identifier hs-var">lexemeParsec</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser ([PWarning] -&gt; (a, [PWarning]))
-&gt; ParsecParser [PWarning] -&gt; ParsecParser (a, [PWarning])
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] [PWarning]
-&gt; ParsecParser [PWarning]
forall a. Parsec FieldLineStream [PWarning] a -&gt; ParsecParser a
</span><a href="Distribution.Parsec.html#liftParsec"><span class="hs-identifier hs-var">liftParsec</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] [PWarning]
forall (m :: * -&gt; *) s u. Monad m =&gt; ParsecT s u m u
</span><a href="../../parsec/src/Text.Parsec.Prim.html#getState"><span class="hs-identifier hs-var">Parsec.getState</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;simpleParsec&gt;&quot;</span></span><span>
</span><span id="line-207"></span><span>    </span><span class="annot"><span class="annottext">(FieldLineStream -&gt; Either ParseError (a, [PWarning]))
-&gt; (String -&gt; FieldLineStream)
-&gt; String
-&gt; Either ParseError (a, [PWarning])
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; FieldLineStream
</span><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromString"><span class="hs-identifier hs-var">fieldLineStreamFromString</span></a></span><span>
</span><span id="line-208"></span><span>
</span><span id="line-209"></span><span class="hs-comment">-- | Parse a 'String' with 'lexemeParsec'.</span><span>
</span><span id="line-210"></span><span id="local-6989586621679629486"><span class="annot"><a href="Distribution.Parsec.html#eitherParsec"><span class="hs-identifier hs-type">eitherParsec</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629486"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629486"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-211"></span><span id="eitherParsec"><span class="annot"><span class="annottext">eitherParsec :: forall a. Parsec a =&gt; String -&gt; Either String a
</span><a href="Distribution.Parsec.html#eitherParsec"><span class="hs-identifier hs-var hs-var">eitherParsec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; String -&gt; Either String a
forall a. ParsecParser a -&gt; String -&gt; Either String a
</span><a href="Distribution.Parsec.html#explicitEitherParsec"><span class="hs-identifier hs-var">explicitEitherParsec</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
forall a (m :: * -&gt; *). (Parsec a, CabalParsing m) =&gt; m a
</span><a href="Distribution.Parsec.html#parsec"><span class="hs-identifier hs-var">parsec</span></a></span><span>
</span><span id="line-212"></span><span>
</span><span id="line-213"></span><span class="hs-comment">-- | Parse a 'String' with given 'ParsecParser'. Trailing whitespace is accepted.</span><span>
</span><span id="line-214"></span><span id="local-6989586621679629484"><span class="annot"><a href="Distribution.Parsec.html#explicitEitherParsec"><span class="hs-identifier hs-type">explicitEitherParsec</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629484"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629484"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-215"></span><span id="explicitEitherParsec"><span class="annot"><span class="annottext">explicitEitherParsec :: forall a. ParsecParser a -&gt; String -&gt; Either String a
</span><a href="Distribution.Parsec.html#explicitEitherParsec"><span class="hs-identifier hs-var hs-var">explicitEitherParsec</span></a></span></span><span> </span><span id="local-6989586621679629017"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629017"><span class="hs-identifier hs-var">parser</span></a></span></span><span>
</span><span id="line-216"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ParseError -&gt; Either String a)
-&gt; (a -&gt; Either String a) -&gt; Either ParseError a -&gt; Either String a
forall a c b. (a -&gt; c) -&gt; (b -&gt; c) -&gt; Either a b -&gt; c
</span><a href="../../base/src/Data.Either.html#either"><span class="hs-identifier hs-var">either</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Either String a
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; Either String a)
-&gt; (ParseError -&gt; String) -&gt; ParseError -&gt; Either String a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ParseError -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a -&gt; Either String a
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span>
</span><span id="line-217"></span><span>    </span><span class="annot"><span class="annottext">(Either ParseError a -&gt; Either String a)
-&gt; (String -&gt; Either ParseError a) -&gt; String -&gt; Either String a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
forall a.
ParsecParser a -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser"><span class="hs-identifier hs-var">runParsecParser</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629017"><span class="hs-identifier hs-var">parser</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; ParsecParser () -&gt; ParsecParser a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;eitherParsec&gt;&quot;</span></span><span>
</span><span id="line-218"></span><span>    </span><span class="annot"><span class="annottext">(FieldLineStream -&gt; Either ParseError a)
-&gt; (String -&gt; FieldLineStream) -&gt; String -&gt; Either ParseError a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; FieldLineStream
</span><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromString"><span class="hs-identifier hs-var">fieldLineStreamFromString</span></a></span><span>
</span><span id="line-219"></span><span>
</span><span id="line-220"></span><span class="hs-comment">-- | Parse a 'String' with given 'ParsecParser' and 'CabalSpecVersion'. Trailing whitespace is accepted.</span><span>
</span><span id="line-221"></span><span class="hs-comment">-- See 'explicitEitherParsec'.</span><span>
</span><span id="line-222"></span><span class="hs-comment">--</span><span>
</span><span id="line-223"></span><span class="hs-comment">-- @since 3.4.0.0</span><span>
</span><span id="line-224"></span><span class="hs-comment">--</span><span>
</span><span id="line-225"></span><span id="local-6989586621679629479"><span class="annot"><a href="Distribution.Parsec.html#explicitEitherParsec%27"><span class="hs-identifier hs-type">explicitEitherParsec'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.CabalSpecVersion.html#CabalSpecVersion"><span class="hs-identifier hs-type">CabalSpecVersion</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629479"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629479"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-226"></span><span id="explicitEitherParsec%27"><span class="annot"><span class="annottext">explicitEitherParsec' :: forall a.
CabalSpecVersion -&gt; ParsecParser a -&gt; String -&gt; Either String a
</span><a href="Distribution.Parsec.html#explicitEitherParsec%27"><span class="hs-identifier hs-var hs-var">explicitEitherParsec'</span></a></span></span><span> </span><span id="local-6989586621679629012"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629012"><span class="hs-identifier hs-var">spec</span></a></span></span><span> </span><span id="local-6989586621679629011"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629011"><span class="hs-identifier hs-var">parser</span></a></span></span><span>
</span><span id="line-227"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(ParseError -&gt; Either String a)
-&gt; (a -&gt; Either String a) -&gt; Either ParseError a -&gt; Either String a
forall a c b. (a -&gt; c) -&gt; (b -&gt; c) -&gt; Either a b -&gt; c
</span><a href="../../base/src/Data.Either.html#either"><span class="hs-identifier hs-var">either</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Either String a
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; Either String a)
-&gt; (ParseError -&gt; String) -&gt; ParseError -&gt; Either String a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">ParseError -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a -&gt; Either String a
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span>
</span><span id="line-228"></span><span>    </span><span class="annot"><span class="annottext">(Either ParseError a -&gt; Either String a)
-&gt; (String -&gt; Either ParseError a) -&gt; String -&gt; Either String a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
forall a.
CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser%27"><span class="hs-identifier hs-var">runParsecParser'</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629012"><span class="hs-identifier hs-var">spec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629011"><span class="hs-identifier hs-var">parser</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a -&gt; ParsecParser () -&gt; ParsecParser a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;eitherParsec&gt;&quot;</span></span><span>
</span><span id="line-229"></span><span>    </span><span class="annot"><span class="annottext">(FieldLineStream -&gt; Either ParseError a)
-&gt; (String -&gt; FieldLineStream) -&gt; String -&gt; Either ParseError a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; FieldLineStream
</span><a href="Distribution.Parsec.FieldLineStream.html#fieldLineStreamFromString"><span class="hs-identifier hs-var">fieldLineStreamFromString</span></a></span><span>
</span><span id="line-230"></span><span>
</span><span id="line-231"></span><span class="hs-comment">-- | Run 'ParsecParser' with 'cabalSpecLatest'.</span><span>
</span><span id="line-232"></span><span id="local-6989586621679629503"><span class="annot"><a href="Distribution.Parsec.html#runParsecParser"><span class="hs-identifier hs-type">runParsecParser</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629503"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.IO.html#FilePath"><span class="hs-identifier hs-type">FilePath</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html#FieldLineStream"><span class="hs-identifier hs-type">FieldLineStream</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="../../parsec/src/Text.Parsec.Error.html#ParseError"><span class="hs-identifier hs-type">Parsec.ParseError</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629503"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-233"></span><span id="runParsecParser"><span class="annot"><span class="annottext">runParsecParser :: forall a.
ParsecParser a -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser"><span class="hs-identifier hs-var hs-var">runParsecParser</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
forall a.
CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser%27"><span class="hs-identifier hs-var">runParsecParser'</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="Distribution.CabalSpecVersion.html#cabalSpecLatest"><span class="hs-identifier hs-var">cabalSpecLatest</span></a></span><span>
</span><span id="line-234"></span><span>
</span><span id="line-235"></span><span class="hs-comment">-- | Like 'runParsecParser' but lets specify 'CabalSpecVersion' used.</span><span>
</span><span id="line-236"></span><span class="hs-comment">--</span><span>
</span><span id="line-237"></span><span class="hs-comment">-- @since 3.0.0.0</span><span>
</span><span id="line-238"></span><span class="hs-comment">--</span><span>
</span><span id="line-239"></span><span id="local-6989586621679629497"><span class="annot"><a href="Distribution.Parsec.html#runParsecParser%27"><span class="hs-identifier hs-type">runParsecParser'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.CabalSpecVersion.html#CabalSpecVersion"><span class="hs-identifier hs-type">CabalSpecVersion</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#ParsecParser"><span class="hs-identifier hs-type">ParsecParser</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629497"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.IO.html#FilePath"><span class="hs-identifier hs-type">FilePath</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Distribution.Parsec.FieldLineStream.html#FieldLineStream"><span class="hs-identifier hs-type">FieldLineStream</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="../../parsec/src/Text.Parsec.Error.html#ParseError"><span class="hs-identifier hs-type">Parsec.ParseError</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629497"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-240"></span><span id="runParsecParser%27"><span class="annot"><span class="annottext">runParsecParser' :: forall a.
CabalSpecVersion
-&gt; ParsecParser a
-&gt; String
-&gt; FieldLineStream
-&gt; Either ParseError a
</span><a href="Distribution.Parsec.html#runParsecParser%27"><span class="hs-identifier hs-var hs-var">runParsecParser'</span></a></span></span><span> </span><span id="local-6989586621679629002"><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629002"><span class="hs-identifier hs-var">v</span></a></span></span><span> </span><span id="local-6989586621679629001"><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629001"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679629000"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679629000"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; [PWarning] -&gt; String -&gt; FieldLineStream -&gt; Either ParseError a
forall s t u a.
Stream s Identity t =&gt;
Parsec s u a -&gt; u -&gt; String -&gt; s -&gt; Either ParseError a
</span><a href="../../parsec/src/Text.Parsec.Prim.html#runParser"><span class="hs-identifier hs-var">Parsec.runParser</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
forall a.
ParsecParser a
-&gt; CabalSpecVersion -&gt; Parsec FieldLineStream [PWarning] a
</span><a href="Distribution.Parsec.html#unPP"><span class="hs-identifier hs-var hs-var">unPP</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecParser a
</span><a href="#local-6989586621679629001"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">CabalSpecVersion
</span><a href="#local-6989586621679629002"><span class="hs-identifier hs-var">v</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] a
-&gt; Parsec FieldLineStream [PWarning] ()
-&gt; Parsec FieldLineStream [PWarning] a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">Parsec FieldLineStream [PWarning] ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">P.eof</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679629000"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-241"></span><span>
</span><span id="line-242"></span><span id="local-6989586621679629470"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629470"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629470"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-243"></span><span>    </span><span id="local-6989586621679628984"><span class="annot"><span class="annottext">parsec :: forall (m :: * -&gt; *). CabalParsing m =&gt; m (Identity a)
</span><a href="#local-6989586621679628984"><span class="hs-identifier hs-var hs-var hs-var hs-var">parsec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Identity a
forall a. a -&gt; Identity a
</span><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-var">Identity</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; Identity a) -&gt; m a -&gt; m (Identity a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
forall a (m :: * -&gt; *). (Parsec a, CabalParsing m) =&gt; m a
</span><a href="Distribution.Parsec.html#parsec"><span class="hs-identifier hs-var">parsec</span></a></span></span><span>
</span><span id="line-244"></span><span>
</span><span id="line-245"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-246"></span><span>    </span><span id="local-6989586621679628972"><span class="annot"><span class="annottext">parsec :: forall (m :: * -&gt; *). CabalParsing m =&gt; m Bool
</span><a href="#local-6989586621679628972"><span class="hs-identifier hs-var hs-var hs-var hs-var">parsec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m String
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m String
</span><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-identifier hs-var">P.munch1</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlpha"><span class="hs-identifier hs-var">isAlpha</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; (String -&gt; m Bool) -&gt; m Bool
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m Bool
forall {f :: * -&gt; *}. CabalParsing f =&gt; String -&gt; f Bool
</span><a href="#local-6989586621679628969"><span class="hs-identifier hs-var">postprocess</span></a></span><span>
</span><span id="line-247"></span><span>      </span><span class="hs-keyword">where</span><span>
</span><span id="line-248"></span><span>        </span><span id="local-6989586621679628969"><span class="annot"><span class="annottext">postprocess :: String -&gt; f Bool
</span><a href="#local-6989586621679628969"><span class="hs-identifier hs-var hs-var">postprocess</span></a></span></span><span> </span><span id="local-6989586621679628946"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628946"><span class="hs-identifier hs-var">str</span></a></span></span><span>
</span><span id="line-249"></span><span>            </span><span class="hs-glyph">|</span><span>  </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628946"><span class="hs-identifier hs-var">str</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;True&quot;</span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; f Bool
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-250"></span><span>            </span><span class="hs-glyph">|</span><span>  </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628946"><span class="hs-identifier hs-var">str</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;False&quot;</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; f Bool
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-251"></span><span>            </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628945"><span class="hs-identifier hs-var">lstr</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;true&quot;</span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PWarnType -&gt; String -&gt; f ()
forall (m :: * -&gt; *). CabalParsing m =&gt; PWarnType -&gt; String -&gt; m ()
</span><a href="Distribution.Parsec.html#parsecWarning"><span class="hs-identifier hs-var">parsecWarning</span></a></span><span> </span><span class="annot"><span class="annottext">PWarnType
</span><a href="Distribution.Parsec.Warning.html#PWTBoolCase"><span class="hs-identifier hs-var">PWTBoolCase</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628943"><span class="hs-identifier hs-var">caseWarning</span></a></span><span> </span><span class="annot"><span class="annottext">f () -&gt; f Bool -&gt; f Bool
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; f Bool
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-252"></span><span>            </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628945"><span class="hs-identifier hs-var">lstr</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;false&quot;</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PWarnType -&gt; String -&gt; f ()
forall (m :: * -&gt; *). CabalParsing m =&gt; PWarnType -&gt; String -&gt; m ()
</span><a href="Distribution.Parsec.html#parsecWarning"><span class="hs-identifier hs-var">parsecWarning</span></a></span><span> </span><span class="annot"><span class="annottext">PWarnType
</span><a href="Distribution.Parsec.Warning.html#PWTBoolCase"><span class="hs-identifier hs-var">PWTBoolCase</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628943"><span class="hs-identifier hs-var">caseWarning</span></a></span><span> </span><span class="annot"><span class="annottext">f () -&gt; f Bool -&gt; f Bool
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; f Bool
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-253"></span><span>            </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; f Bool
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; f Bool) -&gt; String -&gt; f Bool
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Not a boolean: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628946"><span class="hs-identifier hs-var">str</span></a></span><span>
</span><span id="line-254"></span><span>          </span><span class="hs-keyword">where</span><span>
</span><span id="line-255"></span><span>            </span><span id="local-6989586621679628945"><span class="annot"><span class="annottext">lstr :: String
</span><a href="#local-6989586621679628945"><span class="hs-identifier hs-var hs-var">lstr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Char) -&gt; String -&gt; String
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char
</span><a href="../../base/src/GHC.Unicode.html#toLower"><span class="hs-identifier hs-var">toLower</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628946"><span class="hs-identifier hs-var">str</span></a></span><span>
</span><span id="line-256"></span><span>            </span><span id="local-6989586621679628943"><span class="annot"><span class="annottext">caseWarning :: String
</span><a href="#local-6989586621679628943"><span class="hs-identifier hs-var hs-var">caseWarning</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-257"></span><span>                </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Boolean values are case sensitive, use 'True' or 'False'.&quot;</span></span><span>
</span><span id="line-258"></span><span>
</span><span id="line-259"></span><span class="hs-comment">-- | @[^ ,]@</span><span>
</span><span id="line-260"></span><span id="local-6989586621679629459"><span class="annot"><a href="Distribution.Parsec.html#parsecToken"><span class="hs-identifier hs-type">parsecToken</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629459"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629459"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span></span><span>
</span><span id="line-261"></span><span id="parsecToken"><span class="annot"><span class="annottext">parsecToken :: forall (m :: * -&gt; *). CabalParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#parsecToken"><span class="hs-identifier hs-var hs-var">parsecToken</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m String
forall (m :: * -&gt; *). CabalParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#parsecHaskellString"><span class="hs-identifier hs-var">parsecHaskellString</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m String
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m String
</span><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-identifier hs-var">P.munch1</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679628928"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628928"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool
</span><span class="hs-identifier hs-var">not</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isSpace"><span class="hs-identifier hs-var">isSpace</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628928"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628928"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span class="hs-special">)</span><span>  </span><span class="annot"><span class="annottext">m String -&gt; String -&gt; m String
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;identifier&quot;</span></span><span> </span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m String -&gt; (String -&gt; m String) -&gt; m String
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *). CabalParsing m =&gt; String -&gt; m String
</span><a href="Distribution.Parsec.html#checkNotDoubleDash"><span class="hs-identifier hs-var">checkNotDoubleDash</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-262"></span><span>
</span><span id="line-263"></span><span class="hs-comment">-- | @[^ ]@</span><span>
</span><span id="line-264"></span><span id="local-6989586621679628922"><span class="annot"><a href="Distribution.Parsec.html#parsecToken%27"><span class="hs-identifier hs-type">parsecToken'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628922"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628922"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span></span><span>
</span><span id="line-265"></span><span id="parsecToken%27"><span class="annot"><span class="annottext">parsecToken' :: forall (m :: * -&gt; *). CabalParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#parsecToken%27"><span class="hs-identifier hs-var hs-var">parsecToken'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m String
forall (m :: * -&gt; *). CabalParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#parsecHaskellString"><span class="hs-identifier hs-var">parsecHaskellString</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m String
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m String
</span><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-identifier hs-var">P.munch1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Bool -&gt; Bool
</span><span class="hs-identifier hs-var">not</span></span><span> </span><span class="annot"><span class="annottext">(Bool -&gt; Bool) -&gt; (Char -&gt; Bool) -&gt; Char -&gt; Bool
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isSpace"><span class="hs-identifier hs-var">isSpace</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m String -&gt; String -&gt; m String
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;token&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m String -&gt; (String -&gt; m String) -&gt; m String
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *). CabalParsing m =&gt; String -&gt; m String
</span><a href="Distribution.Parsec.html#checkNotDoubleDash"><span class="hs-identifier hs-var">checkNotDoubleDash</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-266"></span><span>
</span><span id="line-267"></span><span id="local-6989586621679629457"><span class="annot"><a href="Distribution.Parsec.html#checkNotDoubleDash"><span class="hs-identifier hs-type">checkNotDoubleDash</span></a></span><span> </span><span class="hs-glyph">::</span><span>  </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629457"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629457"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span></span><span>
</span><span id="line-268"></span><span id="checkNotDoubleDash"><span class="annot"><span class="annottext">checkNotDoubleDash :: forall (m :: * -&gt; *). CabalParsing m =&gt; String -&gt; m String
</span><a href="Distribution.Parsec.html#checkNotDoubleDash"><span class="hs-identifier hs-var hs-var">checkNotDoubleDash</span></a></span></span><span> </span><span id="local-6989586621679628896"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628896"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-269"></span><span>    </span><span class="annot"><span class="annottext">Bool -&gt; m () -&gt; m ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628896"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;--&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(m () -&gt; m ()) -&gt; m () -&gt; m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">PWarnType -&gt; String -&gt; m ()
forall (m :: * -&gt; *). CabalParsing m =&gt; PWarnType -&gt; String -&gt; m ()
</span><a href="Distribution.Parsec.html#parsecWarning"><span class="hs-identifier hs-var">parsecWarning</span></a></span><span> </span><span class="annot"><span class="annottext">PWarnType
</span><a href="Distribution.Parsec.Warning.html#PWTDoubleDash"><span class="hs-identifier hs-var">PWTDoubleDash</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; m ()) -&gt; String -&gt; m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String
</span><a href="../../base/src/Data.OldList.html#unwords"><span class="hs-identifier hs-var">unwords</span></a></span><span>
</span><span id="line-270"></span><span>        </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Double-dash token found.&quot;</span></span><span>
</span><span id="line-271"></span><span>        </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Note: there are no end-of-line comments in .cabal files, only whole line comments.&quot;</span></span><span>
</span><span id="line-272"></span><span>        </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Use \&quot;--\&quot; (quoted double dash) to silence this warning, if you actually want -- token&quot;</span></span><span>
</span><span id="line-273"></span><span>        </span><span class="hs-special">]</span><span>
</span><span id="line-274"></span><span>
</span><span id="line-275"></span><span>    </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628896"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-276"></span><span>
</span><span id="line-277"></span><span id="local-6989586621679628892"><span class="annot"><a href="Distribution.Parsec.html#parsecFilePath"><span class="hs-identifier hs-type">parsecFilePath</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628892"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628892"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.IO.html#FilePath"><span class="hs-identifier hs-type">FilePath</span></a></span></span><span>
</span><span id="line-278"></span><span id="parsecFilePath"><span class="annot"><span class="annottext">parsecFilePath :: forall (m :: * -&gt; *). CabalParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#parsecFilePath"><span class="hs-identifier hs-var hs-var">parsecFilePath</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m String
forall (m :: * -&gt; *). CabalParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#parsecToken"><span class="hs-identifier hs-var">parsecToken</span></a></span><span>
</span><span id="line-279"></span><span>
</span><span id="line-280"></span><span class="hs-comment">-- | Parse a benchmark/test-suite types.</span><span>
</span><span id="line-281"></span><span id="local-6989586621679629450"><span id="local-6989586621679629451"><span id="local-6989586621679629452"><span class="annot"><a href="Distribution.Parsec.html#parsecStandard"><span class="hs-identifier hs-type">parsecStandard</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629452"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#Parsec"><span class="hs-identifier hs-type">Parsec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629451"><span class="hs-identifier hs-type">ver</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679629451"><span class="hs-identifier hs-type">ver</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629450"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629452"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629450"><span class="hs-identifier hs-type">a</span></a></span></span></span></span><span>
</span><span id="line-282"></span><span id="parsecStandard"><span class="annot"><span class="annottext">parsecStandard :: forall (m :: * -&gt; *) ver a.
(CabalParsing m, Parsec ver) =&gt;
(ver -&gt; String -&gt; a) -&gt; m a
</span><a href="Distribution.Parsec.html#parsecStandard"><span class="hs-identifier hs-var hs-var">parsecStandard</span></a></span></span><span> </span><span id="local-6989586621679628871"><span class="annot"><span class="annottext">ver -&gt; String -&gt; a
</span><a href="#local-6989586621679628871"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-283"></span><span>    </span><span id="local-6989586621679628870"><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679628870"><span class="hs-identifier hs-var">cs</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m String -&gt; m [String]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#some"><span class="hs-identifier hs-var">some</span></a></span><span> </span><span class="annot"><span class="annottext">(m String -&gt; m [String]) -&gt; m String -&gt; m [String]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">P.try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m String
</span><a href="#local-6989586621679628869"><span class="hs-identifier hs-var">component</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; m Char -&gt; m String
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'-'</span></span><span class="hs-special">)</span><span>
</span><span id="line-284"></span><span>    </span><span id="local-6989586621679628868"><span class="annot"><span class="annottext">ver
</span><a href="#local-6989586621679628868"><span class="hs-identifier hs-var">ver</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m ver
forall a (m :: * -&gt; *). (Parsec a, CabalParsing m) =&gt; m a
</span><a href="Distribution.Parsec.html#parsec"><span class="hs-identifier hs-var">parsec</span></a></span><span>
</span><span id="line-285"></span><span>    </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679628867"><span class="annot"><span class="annottext">name :: String
</span><a href="#local-6989586621679628867"><span class="hs-identifier hs-var hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Char) -&gt; String -&gt; String
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char
</span><a href="../../base/src/GHC.Unicode.html#toLower"><span class="hs-identifier hs-var">toLower</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; String
forall a. [a] -&gt; [[a]] -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#intercalate"><span class="hs-identifier hs-var">intercalate</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;-&quot;</span></span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679628870"><span class="hs-identifier hs-var">cs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-286"></span><span>    </span><span class="annot"><span class="annottext">a -&gt; m a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; m a) -&gt; a -&gt; m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">ver -&gt; String -&gt; a
</span><a href="#local-6989586621679628871"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">ver
</span><a href="#local-6989586621679628868"><span class="hs-identifier hs-var">ver</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628867"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-287"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-288"></span><span>    </span><span id="local-6989586621679628869"><span class="annot"><span class="annottext">component :: m String
</span><a href="#local-6989586621679628869"><span class="hs-identifier hs-var hs-var">component</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-289"></span><span>      </span><span id="local-6989586621679628859"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628859"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m String
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m String
</span><a href="Distribution.Compat.CharParsing.html#munch1"><span class="hs-identifier hs-var">P.munch1</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlphaNum"><span class="hs-identifier hs-var">isAlphaNum</span></a></span><span>
</span><span id="line-290"></span><span>      </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; String -&gt; Bool
forall (t :: * -&gt; *) a. Foldable t =&gt; (a -&gt; Bool) -&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#all"><span class="hs-identifier hs-var">all</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isDigit"><span class="hs-identifier hs-var">isDigit</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628859"><span class="hs-identifier hs-var">cs</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;all digit component&quot;</span></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628859"><span class="hs-identifier hs-var">cs</span></a></span><span>
</span><span id="line-291"></span><span>      </span><span class="hs-comment">-- each component must contain an alphabetic character, to avoid</span><span>
</span><span id="line-292"></span><span>      </span><span class="hs-comment">-- ambiguity in identifiers like foo-1 (the 1 is the version number).</span><span>
</span><span id="line-293"></span><span>
</span><span id="line-294"></span><span id="local-6989586621679629442"><span id="local-6989586621679629443"><span class="annot"><a href="Distribution.Parsec.html#parsecCommaList"><span class="hs-identifier hs-type">parsecCommaList</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629443"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629443"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629442"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629443"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679629442"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-295"></span><span id="parsecCommaList"><span class="annot"><span class="annottext">parsecCommaList :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m [a]
</span><a href="Distribution.Parsec.html#parsecCommaList"><span class="hs-identifier hs-var hs-var">parsecCommaList</span></a></span></span><span> </span><span id="local-6989586621679628843"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628843"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m [a]
forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#sepBy"><span class="hs-identifier hs-var">P.sepBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628843"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; String -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;comma&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-296"></span><span>
</span><span id="line-297"></span><span id="local-6989586621679629435"><span id="local-6989586621679629436"><span class="annot"><a href="Distribution.Parsec.html#parsecCommaNonEmpty"><span class="hs-identifier hs-type">parsecCommaNonEmpty</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629436"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629436"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629435"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629436"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629435"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-298"></span><span id="parsecCommaNonEmpty"><span class="annot"><span class="annottext">parsecCommaNonEmpty :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m (NonEmpty a)
</span><a href="Distribution.Parsec.html#parsecCommaNonEmpty"><span class="hs-identifier hs-var hs-var">parsecCommaNonEmpty</span></a></span></span><span> </span><span id="local-6989586621679628829"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628829"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier hs-var">P.sepByNonEmpty</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628829"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; String -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;comma&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-299"></span><span>
</span><span id="line-300"></span><span class="hs-comment">-- | Like 'parsecCommaList' but accept leading or trailing comma.</span><span>
</span><span id="line-301"></span><span class="hs-comment">--</span><span>
</span><span id="line-302"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-303"></span><span class="hs-comment">-- p (comma p)*  -- p `sepBy` comma</span><span>
</span><span id="line-304"></span><span class="hs-comment">-- (comma p)*    -- leading comma</span><span>
</span><span id="line-305"></span><span class="hs-comment">-- (p comma)*    -- trailing comma</span><span>
</span><span id="line-306"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-307"></span><span id="local-6989586621679628826"><span id="local-6989586621679628827"><span class="annot"><a href="Distribution.Parsec.html#parsecLeadingCommaList"><span class="hs-identifier hs-type">parsecLeadingCommaList</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628827"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628827"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628826"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628827"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679628826"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-308"></span><span id="parsecLeadingCommaList"><span class="annot"><span class="annottext">parsecLeadingCommaList :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m [a]
</span><a href="Distribution.Parsec.html#parsecLeadingCommaList"><span class="hs-identifier hs-var hs-var">parsecLeadingCommaList</span></a></span></span><span> </span><span id="local-6989586621679628804"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628804"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-309"></span><span>    </span><span id="local-6989586621679628803"><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628803"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m () -&gt; m (Maybe ())
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f (Maybe a)
</span><a href="../../base/src/Control.Applicative.html#optional"><span class="hs-identifier hs-var">P.optional</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628801"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-310"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628803"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-311"></span><span>        </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">NonEmpty a -&gt; [a]
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; [a]
</span><a href="../../base/src/Data.Foldable.html#toList"><span class="hs-identifier hs-var">toList</span></a></span><span> </span><span class="annot"><span class="annottext">(NonEmpty a -&gt; [a]) -&gt; m (NonEmpty a) -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepEndByNonEmpty"><span class="hs-identifier hs-var">P.sepEndByNonEmpty</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628798"><span class="hs-identifier hs-var">lp</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628801"><span class="hs-identifier hs-var">comma</span></a></span><span> </span><span class="annot"><span class="annottext">m [a] -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; m [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-312"></span><span>        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">NonEmpty a -&gt; [a]
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; [a]
</span><a href="../../base/src/Data.Foldable.html#toList"><span class="hs-identifier hs-var">toList</span></a></span><span> </span><span class="annot"><span class="annottext">(NonEmpty a -&gt; [a]) -&gt; m (NonEmpty a) -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier hs-var">P.sepByNonEmpty</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628798"><span class="hs-identifier hs-var">lp</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628801"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-313"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-314"></span><span>    </span><span id="local-6989586621679628798"><span class="annot"><span class="annottext">lp :: m a
</span><a href="#local-6989586621679628798"><span class="hs-identifier hs-var hs-var">lp</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628804"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span>
</span><span id="line-315"></span><span>    </span><span id="local-6989586621679628801"><span class="annot"><span class="annottext">comma :: m ()
</span><a href="#local-6989586621679628801"><span class="hs-identifier hs-var hs-var">comma</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; String -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;comma&quot;</span></span><span>
</span><span id="line-316"></span><span>
</span><span id="line-317"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-318"></span><span class="hs-comment">--</span><span>
</span><span id="line-319"></span><span class="hs-comment">-- @since 3.4.0.0</span><span>
</span><span id="line-320"></span><span id="local-6989586621679628792"><span id="local-6989586621679628793"><span class="annot"><a href="Distribution.Parsec.html#parsecLeadingCommaNonEmpty"><span class="hs-identifier hs-type">parsecLeadingCommaNonEmpty</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628793"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628793"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628792"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628793"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628792"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-321"></span><span id="parsecLeadingCommaNonEmpty"><span class="annot"><span class="annottext">parsecLeadingCommaNonEmpty :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m (NonEmpty a)
</span><a href="Distribution.Parsec.html#parsecLeadingCommaNonEmpty"><span class="hs-identifier hs-var hs-var">parsecLeadingCommaNonEmpty</span></a></span></span><span> </span><span id="local-6989586621679628778"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628778"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-322"></span><span>    </span><span id="local-6989586621679628777"><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628777"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m () -&gt; m (Maybe ())
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f (Maybe a)
</span><a href="../../base/src/Control.Applicative.html#optional"><span class="hs-identifier hs-var">P.optional</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628776"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-323"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628777"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-324"></span><span>        </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepEndByNonEmpty"><span class="hs-identifier hs-var">P.sepEndByNonEmpty</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628775"><span class="hs-identifier hs-var">lp</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628776"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-325"></span><span>        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier hs-var">P.sepByNonEmpty</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628775"><span class="hs-identifier hs-var">lp</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628776"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-326"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-327"></span><span>    </span><span id="local-6989586621679628775"><span class="annot"><span class="annottext">lp :: m a
</span><a href="#local-6989586621679628775"><span class="hs-identifier hs-var hs-var">lp</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628778"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span>
</span><span id="line-328"></span><span>    </span><span id="local-6989586621679628776"><span class="annot"><span class="annottext">comma :: m ()
</span><a href="#local-6989586621679628776"><span class="hs-identifier hs-var hs-var">comma</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; String -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;comma&quot;</span></span><span>
</span><span id="line-329"></span><span>
</span><span id="line-330"></span><span id="local-6989586621679628769"><span id="local-6989586621679628770"><span class="annot"><a href="Distribution.Parsec.html#parsecOptCommaList"><span class="hs-identifier hs-type">parsecOptCommaList</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628770"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628770"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628769"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628770"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679628769"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-331"></span><span id="parsecOptCommaList"><span class="annot"><span class="annottext">parsecOptCommaList :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m [a]
</span><a href="Distribution.Parsec.html#parsecOptCommaList"><span class="hs-identifier hs-var hs-var">parsecOptCommaList</span></a></span></span><span> </span><span id="local-6989586621679628759"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628759"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m (Maybe ()) -&gt; m [a]
forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#sepBy"><span class="hs-identifier hs-var">P.sepBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628759"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m () -&gt; m (Maybe ())
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f (Maybe a)
</span><a href="../../base/src/Control.Applicative.html#optional"><span class="hs-identifier hs-var">P.optional</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628758"><span class="hs-identifier hs-var">comma</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-332"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-333"></span><span>    </span><span id="local-6989586621679628758"><span class="annot"><span class="annottext">comma :: m ()
</span><a href="#local-6989586621679628758"><span class="hs-identifier hs-var hs-var">comma</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span>
</span><span id="line-334"></span><span>
</span><span id="line-335"></span><span class="hs-comment">-- | Like 'parsecOptCommaList' but</span><span>
</span><span id="line-336"></span><span class="hs-comment">--</span><span>
</span><span id="line-337"></span><span class="hs-comment">-- * require all or none commas</span><span>
</span><span id="line-338"></span><span class="hs-comment">-- * accept leading or trailing comma.</span><span>
</span><span id="line-339"></span><span class="hs-comment">--</span><span>
</span><span id="line-340"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-341"></span><span class="hs-comment">-- p (comma p)*  -- p `sepBy` comma</span><span>
</span><span id="line-342"></span><span class="hs-comment">-- (comma p)*    -- leading comma</span><span>
</span><span id="line-343"></span><span class="hs-comment">-- (p comma)*    -- trailing comma</span><span>
</span><span id="line-344"></span><span class="hs-comment">-- p*            -- no commas: many p</span><span>
</span><span id="line-345"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-346"></span><span class="hs-comment">--</span><span>
</span><span id="line-347"></span><span class="hs-comment">-- @since 3.0.0.0</span><span>
</span><span id="line-348"></span><span class="hs-comment">--</span><span>
</span><span id="line-349"></span><span id="local-6989586621679628753"><span id="local-6989586621679628754"><span class="annot"><a href="Distribution.Parsec.html#parsecLeadingOptCommaList"><span class="hs-identifier hs-type">parsecLeadingOptCommaList</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628754"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628754"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628753"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628754"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679628753"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-350"></span><span id="parsecLeadingOptCommaList"><span class="annot"><span class="annottext">parsecLeadingOptCommaList :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m [a]
</span><a href="Distribution.Parsec.html#parsecLeadingOptCommaList"><span class="hs-identifier hs-var hs-var">parsecLeadingOptCommaList</span></a></span></span><span> </span><span id="local-6989586621679628728"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628728"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-351"></span><span>    </span><span id="local-6989586621679628727"><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628727"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m () -&gt; m (Maybe ())
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f (Maybe a)
</span><a href="../../base/src/Control.Applicative.html#optional"><span class="hs-identifier hs-var">P.optional</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628726"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-352"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628727"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-353"></span><span>        </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m [a]
</span><a href="#local-6989586621679628725"><span class="hs-identifier hs-var">sepEndBy1Start</span></a></span><span> </span><span class="annot"><span class="annottext">m [a] -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; m [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-354"></span><span>        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">NonEmpty a -&gt; [a]
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; [a]
</span><a href="../../base/src/Data.Foldable.html#toList"><span class="hs-identifier hs-var">toList</span></a></span><span> </span><span class="annot"><span class="annottext">(NonEmpty a -&gt; [a]) -&gt; m (NonEmpty a) -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier hs-var">P.sepByNonEmpty</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628724"><span class="hs-identifier hs-var">lp</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628726"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-355"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-356"></span><span>    </span><span id="local-6989586621679628724"><span class="annot"><span class="annottext">lp :: m a
</span><a href="#local-6989586621679628724"><span class="hs-identifier hs-var hs-var">lp</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628728"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span>
</span><span id="line-357"></span><span>    </span><span id="local-6989586621679628726"><span class="annot"><span class="annottext">comma :: m ()
</span><a href="#local-6989586621679628726"><span class="hs-identifier hs-var hs-var">comma</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">','</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#spaces"><span class="hs-identifier hs-var">P.spaces</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; String -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;comma&quot;</span></span><span>
</span><span id="line-358"></span><span>
</span><span id="line-359"></span><span>    </span><span id="local-6989586621679628725"><span class="annot"><span class="annottext">sepEndBy1Start :: m [a]
</span><a href="#local-6989586621679628725"><span class="hs-identifier hs-var hs-var">sepEndBy1Start</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-360"></span><span>        </span><span id="local-6989586621679628719"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679628719"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628724"><span class="hs-identifier hs-var">lp</span></a></span><span>
</span><span id="line-361"></span><span>        </span><span id="local-6989586621679628718"><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628718"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m () -&gt; m (Maybe ())
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f (Maybe a)
</span><a href="../../base/src/Control.Applicative.html#optional"><span class="hs-identifier hs-var">P.optional</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628726"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-362"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="#local-6989586621679628718"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-363"></span><span>            </span><span class="annot"><span class="annottext">Maybe ()
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679628719"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; [a]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">([a] -&gt; [a]) -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628724"><span class="hs-identifier hs-var">lp</span></a></span><span>
</span><span id="line-364"></span><span>            </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679628719"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; [a]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">([a] -&gt; [a]) -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m [a]
forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#sepEndBy"><span class="hs-identifier hs-var">P.sepEndBy</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628724"><span class="hs-identifier hs-var">lp</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628726"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-365"></span><span>
</span><span id="line-366"></span><span class="hs-comment">-- | Content isn't unquoted</span><span>
</span><span id="line-367"></span><span id="local-6989586621679629416"><span id="local-6989586621679629417"><span class="annot"><a href="Distribution.Parsec.html#parsecQuoted"><span class="hs-identifier hs-type">parsecQuoted</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629417"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629417"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629416"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629417"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629416"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-368"></span><span id="parsecQuoted"><span class="annot"><span class="annottext">parsecQuoted :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Parsec.html#parsecQuoted"><span class="hs-identifier hs-var hs-var">parsecQuoted</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Char -&gt; m a -&gt; m a
forall (m :: * -&gt; *) bra ket a.
Applicative m =&gt;
m bra -&gt; m ket -&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#between"><span class="hs-identifier hs-var">P.between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span class="hs-special">)</span><span>
</span><span id="line-369"></span><span>
</span><span id="line-370"></span><span class="hs-comment">-- | @parsecMaybeQuoted p = 'parsecQuoted' p &lt;|&gt; p@.</span><span>
</span><span id="line-371"></span><span id="local-6989586621679628706"><span id="local-6989586621679628707"><span class="annot"><a href="Distribution.Parsec.html#parsecMaybeQuoted"><span class="hs-identifier hs-type">parsecMaybeQuoted</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628707"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628707"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628706"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628707"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628706"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-372"></span><span id="parsecMaybeQuoted"><span class="annot"><span class="annottext">parsecMaybeQuoted :: forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Parsec.html#parsecMaybeQuoted"><span class="hs-identifier hs-var hs-var">parsecMaybeQuoted</span></a></span></span><span> </span><span id="local-6989586621679628699"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628699"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a
forall (m :: * -&gt; *) a. CabalParsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Parsec.html#parsecQuoted"><span class="hs-identifier hs-var">parsecQuoted</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628699"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679628699"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-373"></span><span>
</span><span id="line-374"></span><span class="annot"><a href="Distribution.Parsec.html#parsecUnqualComponentName"><span class="hs-identifier hs-type">parsecUnqualComponentName</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679628698"><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Distribution.Parsec.html#CabalParsing"><span class="hs-identifier hs-type">CabalParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-375"></span><span id="parsecUnqualComponentName"><span class="annot"><span class="annottext">parsecUnqualComponentName :: forall (m :: * -&gt; *). CabalParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#parsecUnqualComponentName"><span class="hs-identifier hs-var hs-var">parsecUnqualComponentName</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; m String
</span><a href="#local-6989586621679628679"><span class="hs-identifier hs-var">state0</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
forall a. DList a
</span><a href="Distribution.Compat.DList.html#empty"><span class="hs-identifier hs-var">DList.empty</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-376"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-377"></span><span>    </span><span class="hs-comment">-- using @kleene@ package we can easily see that</span><span>
</span><span id="line-378"></span><span>    </span><span class="hs-comment">-- we need only two states to recognize</span><span>
</span><span id="line-379"></span><span>    </span><span class="hs-comment">-- unqual-component-name</span><span>
</span><span id="line-380"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-381"></span><span>    </span><span class="hs-comment">-- Compare with declarative</span><span>
</span><span id="line-382"></span><span>    </span><span class="hs-comment">-- 'Distribution.FieldGrammar.Described.reUnqualComponent'.</span><span>
</span><span id="line-383"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-384"></span><span>    </span><span class="hs-comment">-- @</span><span>
</span><span id="line-385"></span><span>    </span><span class="hs-comment">-- import Kleene</span><span>
</span><span id="line-386"></span><span>    </span><span class="hs-comment">-- import Kleene.Internal.Pretty</span><span>
</span><span id="line-387"></span><span>    </span><span class="hs-comment">-- import Algebra.Lattice</span><span>
</span><span id="line-388"></span><span>    </span><span class="hs-comment">-- import Data.Char</span><span>
</span><span id="line-389"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-390"></span><span>    </span><span class="hs-comment">-- import qualified Data.RangeSet.Map as RSet</span><span>
</span><span id="line-391"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-392"></span><span>    </span><span class="hs-comment">-- main = do</span><span>
</span><span id="line-393"></span><span>    </span><span class="hs-comment">--     -- this is an approximation, to get an idea.</span><span>
</span><span id="line-394"></span><span>    </span><span class="hs-comment">--     let component :: RE Char</span><span>
</span><span id="line-395"></span><span>    </span><span class="hs-comment">--         component = star alphaNum &lt;&gt; alpha &lt;&gt; star alphaNum</span><span>
</span><span id="line-396"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-397"></span><span>    </span><span class="hs-comment">--         alphaNum = alpha \/ num</span><span>
</span><span id="line-398"></span><span>    </span><span class="hs-comment">--         alpha    = unions $ map char ['a'..'z']</span><span>
</span><span id="line-399"></span><span>    </span><span class="hs-comment">--         num      = unions $ map char ['0'..'9']</span><span>
</span><span id="line-400"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-401"></span><span>    </span><span class="hs-comment">--         re :: RE Char</span><span>
</span><span id="line-402"></span><span>    </span><span class="hs-comment">--         re = component &lt;&gt; star (char '-' &lt;&gt; component)</span><span>
</span><span id="line-403"></span><span>    </span><span class="hs-comment">--</span><span>
</span><span id="line-404"></span><span>    </span><span class="hs-comment">--     putPretty re</span><span>
</span><span id="line-405"></span><span>    </span><span class="hs-comment">--     putPretty $ fromTM re</span><span>
</span><span id="line-406"></span><span>    </span><span class="hs-comment">-- @</span><span>
</span><span id="line-407"></span><span>
</span><span id="line-408"></span><span>    </span><span class="annot"><a href="#local-6989586621679628679"><span class="hs-identifier hs-type">state0</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.DList.html#DList"><span class="hs-identifier hs-type">DList.DList</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-409"></span><span>    </span><span id="local-6989586621679628679"><span class="annot"><span class="annottext">state0 :: DList Char -&gt; m String
</span><a href="#local-6989586621679628679"><span class="hs-identifier hs-var hs-var">state0</span></a></span></span><span> </span><span id="local-6989586621679628677"><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628677"><span class="hs-identifier hs-var">acc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-410"></span><span>        </span><span id="local-6989586621679628676"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628676"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628675"><span class="hs-identifier hs-var">ch</span></a></span><span> </span><span class="hs-comment">-- &lt;|&gt; fail (&quot;Invalid component, after &quot; ++ DList.toList acc)</span><span>
</span><span id="line-411"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-412"></span><span>            </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isDigit"><span class="hs-identifier hs-var">isDigit</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628676"><span class="hs-identifier hs-var">c</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; m String
</span><a href="#local-6989586621679628679"><span class="hs-identifier hs-var">state0</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DList Char -&gt; Char -&gt; DList Char
forall a. DList a -&gt; a -&gt; DList a
</span><a href="Distribution.Compat.DList.html#snoc"><span class="hs-identifier hs-var">DList.snoc</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628677"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628676"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-413"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlphaNum"><span class="hs-identifier hs-var">isAlphaNum</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628676"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; m String
</span><a href="#local-6989586621679628673"><span class="hs-identifier hs-var">state1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DList Char -&gt; Char -&gt; DList Char
forall a. DList a -&gt; a -&gt; DList a
</span><a href="Distribution.Compat.DList.html#snoc"><span class="hs-identifier hs-var">DList.snoc</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628677"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628676"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-414"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628676"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'-'</span></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Empty component, after &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; String
forall a. DList a -&gt; [a]
</span><a href="Distribution.Compat.DList.html#toList"><span class="hs-identifier hs-var">DList.toList</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628677"><span class="hs-identifier hs-var">acc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-415"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Internal error, after &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; String
forall a. DList a -&gt; [a]
</span><a href="Distribution.Compat.DList.html#toList"><span class="hs-identifier hs-var">DList.toList</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628677"><span class="hs-identifier hs-var">acc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-416"></span><span>
</span><span id="line-417"></span><span>    </span><span class="annot"><a href="#local-6989586621679628673"><span class="hs-identifier hs-type">state1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.DList.html#DList"><span class="hs-identifier hs-type">DList.DList</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-418"></span><span>    </span><span id="local-6989586621679628673"><span class="annot"><span class="annottext">state1 :: DList Char -&gt; m String
</span><a href="#local-6989586621679628673"><span class="hs-identifier hs-var hs-var">state1</span></a></span></span><span> </span><span id="local-6989586621679628671"><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628671"><span class="hs-identifier hs-var">acc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; m String
</span><a href="#local-6989586621679628670"><span class="hs-identifier hs-var">state1'</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628671"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
</span><a href="#local-6989586621679628669"><span class="hs-operator hs-var">`alt`</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DList Char -&gt; String
forall a. DList a -&gt; [a]
</span><a href="Distribution.Compat.DList.html#toList"><span class="hs-identifier hs-var">DList.toList</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628671"><span class="hs-identifier hs-var">acc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-419"></span><span>
</span><span id="line-420"></span><span>    </span><span class="annot"><a href="#local-6989586621679628670"><span class="hs-identifier hs-type">state1'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Distribution.Compat.DList.html#DList"><span class="hs-identifier hs-type">DList.DList</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-421"></span><span>    </span><span id="local-6989586621679628670"><span class="annot"><span class="annottext">state1' :: DList Char -&gt; m String
</span><a href="#local-6989586621679628670"><span class="hs-identifier hs-var hs-var">state1'</span></a></span></span><span> </span><span id="local-6989586621679628668"><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628668"><span class="hs-identifier hs-var">acc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-422"></span><span>        </span><span id="local-6989586621679628667"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628667"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628675"><span class="hs-identifier hs-var">ch</span></a></span><span>
</span><span id="line-423"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-424"></span><span>            </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlphaNum"><span class="hs-identifier hs-var">isAlphaNum</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628667"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; m String
</span><a href="#local-6989586621679628673"><span class="hs-identifier hs-var">state1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DList Char -&gt; Char -&gt; DList Char
forall a. DList a -&gt; a -&gt; DList a
</span><a href="Distribution.Compat.DList.html#snoc"><span class="hs-identifier hs-var">DList.snoc</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628668"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628667"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-425"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628667"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'-'</span></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; m String
</span><a href="#local-6989586621679628679"><span class="hs-identifier hs-var">state0</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DList Char -&gt; Char -&gt; DList Char
forall a. DList a -&gt; a -&gt; DList a
</span><a href="Distribution.Compat.DList.html#snoc"><span class="hs-identifier hs-var">DList.snoc</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628668"><span class="hs-identifier hs-var">acc</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628667"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-426"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Internal error, after &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char -&gt; String
forall a. DList a -&gt; [a]
</span><a href="Distribution.Compat.DList.html#toList"><span class="hs-identifier hs-var">DList.toList</span></a></span><span> </span><span class="annot"><span class="annottext">DList Char
</span><a href="#local-6989586621679628668"><span class="hs-identifier hs-var">acc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-427"></span><span>
</span><span id="line-428"></span><span>    </span><span class="annot"><a href="#local-6989586621679628675"><span class="hs-identifier hs-type">ch</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-429"></span><span>    </span><span class="hs-glyph">!</span><span id="local-6989586621679628675"><span class="annot"><span class="annottext">ch :: m Char
</span><a href="#local-6989586621679628675"><span class="hs-identifier hs-var hs-var">ch</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">P.satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679628666"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628666"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlphaNum"><span class="hs-identifier hs-var">isAlphaNum</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628666"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">||</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628666"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'-'</span></span><span class="hs-special">)</span><span>
</span><span id="line-430"></span><span>
</span><span id="line-431"></span><span>    </span><span class="annot"><a href="#local-6989586621679628669"><span class="hs-identifier hs-type">alt</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628698"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-432"></span><span>    </span><span class="hs-glyph">!</span><span id="local-6989586621679628669"><span class="annot"><span class="annottext">alt :: m String -&gt; m String -&gt; m String
</span><a href="#local-6989586621679628669"><span class="hs-identifier hs-var hs-var">alt</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">(&lt;|&gt;)</span></a></span><span>
</span><span id="line-433"></span><span>
</span><span id="line-434"></span><span class="annot"><a href="Distribution.Parsec.html#stringLiteral"><span class="hs-identifier hs-type">stringLiteral</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679629637"><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">P.CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-435"></span><span id="stringLiteral"><span class="annot"><span class="annottext">stringLiteral :: forall (m :: * -&gt; *). CharParsing m =&gt; m String
</span><a href="Distribution.Parsec.html#stringLiteral"><span class="hs-identifier hs-var hs-var">stringLiteral</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m String
</span><a href="#local-6989586621679628630"><span class="hs-identifier hs-var">lit</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-436"></span><span>    </span><span class="annot"><a href="#local-6989586621679628630"><span class="hs-identifier hs-type">lit</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-437"></span><span>    </span><span id="local-6989586621679628630"><span class="annot"><span class="annottext">lit :: m String
</span><a href="#local-6989586621679628630"><span class="hs-identifier hs-var hs-var">lit</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Maybe Char -&gt; String -&gt; String)
-&gt; String -&gt; [Maybe Char] -&gt; String
forall (t :: * -&gt; *) a b.
Foldable t =&gt;
(a -&gt; b -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldr"><span class="hs-identifier hs-var">foldr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(String -&gt; String)
-&gt; (Char -&gt; String -&gt; String) -&gt; Maybe Char -&gt; String -&gt; String
forall b a. b -&gt; (a -&gt; b) -&gt; Maybe a -&gt; b
</span><a href="../../base/src/Data.Maybe.html#maybe"><span class="hs-identifier hs-var">maybe</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">:</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span>
</span><span id="line-438"></span><span>        </span><span class="annot"><span class="annottext">([Maybe Char] -&gt; String) -&gt; m [Maybe Char] -&gt; m String
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Char -&gt; m [Maybe Char] -&gt; m [Maybe Char]
forall (m :: * -&gt; *) bra ket a.
Applicative m =&gt;
m bra -&gt; m ket -&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#between"><span class="hs-identifier hs-var">P.between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; String -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of string&quot;</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m (Maybe Char) -&gt; m [Maybe Char]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="annot"><span class="annottext">m (Maybe Char)
</span><a href="#local-6989586621679628626"><span class="hs-identifier hs-var">stringChar</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-439"></span><span>        </span><span class="annot"><span class="annottext">m String -&gt; String -&gt; m String
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;string&quot;</span></span><span>
</span><span id="line-440"></span><span>
</span><span id="line-441"></span><span>    </span><span class="annot"><a href="#local-6989586621679628626"><span class="hs-identifier hs-type">stringChar</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">)</span><span>
</span><span id="line-442"></span><span>    </span><span id="local-6989586621679628626"><span class="annot"><span class="annottext">stringChar :: m (Maybe Char)
</span><a href="#local-6989586621679628626"><span class="hs-identifier hs-var hs-var">stringChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Maybe Char
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Maybe Char) -&gt; m Char -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628625"><span class="hs-identifier hs-var">stringLetter</span></a></span><span>
</span><span id="line-443"></span><span>         </span><span class="annot"><span class="annottext">m (Maybe Char) -&gt; m (Maybe Char) -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (Maybe Char)
</span><a href="#local-6989586621679628624"><span class="hs-identifier hs-var">stringEscape</span></a></span><span>
</span><span id="line-444"></span><span>         </span><span class="annot"><span class="annottext">m (Maybe Char) -&gt; String -&gt; m (Maybe Char)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;string character&quot;</span></span><span>
</span><span id="line-445"></span><span>
</span><span id="line-446"></span><span>    </span><span class="annot"><a href="#local-6989586621679628625"><span class="hs-identifier hs-type">stringLetter</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-447"></span><span>    </span><span id="local-6989586621679628625"><span class="annot"><span class="annottext">stringLetter :: m Char
</span><a href="#local-6989586621679628625"><span class="hs-identifier hs-var hs-var">stringLetter</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; (Char -&gt; Bool) -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#satisfy"><span class="hs-identifier hs-var">P.satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679628623"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628623"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628623"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628623"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628623"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\026'</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-448"></span><span>
</span><span id="line-449"></span><span>    </span><span class="annot"><a href="#local-6989586621679628624"><span class="hs-identifier hs-type">stringEscape</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">)</span><span>
</span><span id="line-450"></span><span>    </span><span id="local-6989586621679628624"><span class="annot"><span class="annottext">stringEscape :: m (Maybe Char)
</span><a href="#local-6989586621679628624"><span class="hs-identifier hs-var hs-var">stringEscape</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m (Maybe Char) -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (Maybe Char)
</span><a href="#local-6989586621679628621"><span class="hs-identifier hs-var">esc</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-451"></span><span>        </span><span class="annot"><a href="#local-6989586621679628621"><span class="hs-identifier hs-type">esc</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">)</span><span>
</span><span id="line-452"></span><span>        </span><span id="local-6989586621679628621"><span class="annot"><span class="annottext">esc :: m (Maybe Char)
</span><a href="#local-6989586621679628621"><span class="hs-identifier hs-var hs-var">esc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe Char
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Char -&gt; m Char -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628620"><span class="hs-identifier hs-var">escapeGap</span></a></span><span>
</span><span id="line-453"></span><span>            </span><span class="annot"><span class="annottext">m (Maybe Char) -&gt; m (Maybe Char) -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Char
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Char -&gt; m Char -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628619"><span class="hs-identifier hs-var">escapeEmpty</span></a></span><span>
</span><span id="line-454"></span><span>            </span><span class="annot"><span class="annottext">m (Maybe Char) -&gt; m (Maybe Char) -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Maybe Char
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Maybe Char) -&gt; m Char -&gt; m (Maybe Char)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Parsec.html#escapeCode"><span class="hs-identifier hs-var">escapeCode</span></a></span><span>
</span><span id="line-455"></span><span>
</span><span id="line-456"></span><span>    </span><span class="annot"><a href="#local-6989586621679628619"><span class="hs-identifier hs-type">escapeEmpty</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679628620"><span class="hs-identifier hs-type">escapeGap</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679629637"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-457"></span><span>    </span><span id="local-6989586621679628619"><span class="annot"><span class="annottext">escapeEmpty :: m Char
</span><a href="#local-6989586621679628619"><span class="hs-identifier hs-var hs-var">escapeEmpty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&amp;'</span></span><span>
</span><span id="line-458"></span><span>    </span><span id="local-6989586621679628620"><span class="annot"><span class="annottext">escapeGap :: m Char
</span><a href="#local-6989586621679628620"><span class="hs-identifier hs-var hs-var">escapeGap</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). CharParsing m =&gt; m ()
</span><a href="Distribution.Compat.CharParsing.html#skipSpaces1"><span class="hs-identifier hs-var">P.skipSpaces1</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; m Char -&gt; m Char
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; String -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of string gap&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-459"></span><span>
</span><span id="line-460"></span><span class="annot"><a href="Distribution.Parsec.html#escapeCode"><span class="hs-identifier hs-type">escapeCode</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679628616"><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Distribution.Compat.CharParsing.html#CharParsing"><span class="hs-identifier hs-type">P.CharParsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-461"></span><span id="escapeCode"><span class="annot"><span class="annottext">escapeCode :: forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Parsec.html#escapeCode"><span class="hs-identifier hs-var hs-var">escapeCode</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628517"><span class="hs-identifier hs-var">charEsc</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Char -&gt; m Char
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628516"><span class="hs-identifier hs-var">charNum</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Char -&gt; m Char
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628515"><span class="hs-identifier hs-var">charAscii</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Char -&gt; m Char
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628514"><span class="hs-identifier hs-var">charControl</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; String -&gt; m Char
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">P.&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;escape code&quot;</span></span><span>
</span><span id="line-462"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-463"></span><span>  </span><span class="annot"><a href="#local-6989586621679628514"><span class="hs-identifier hs-type">charControl</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679628516"><span class="hs-identifier hs-type">charNum</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-464"></span><span>  </span><span id="local-6989586621679628514"><span class="annot"><span class="annottext">charControl :: m Char
</span><a href="#local-6989586621679628514"><span class="hs-identifier hs-var hs-var">charControl</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679628513"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628513"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Char
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628513"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'@'</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Char) -&gt; m Char -&gt; m Char
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'^'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Char -&gt; m Char
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m Char
forall (m :: * -&gt; *). CharParsing m =&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#upper"><span class="hs-identifier hs-var">P.upper</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Char -&gt; m Char
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'@'</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-465"></span><span>  </span><span id="local-6989586621679628516"><span class="annot"><span class="annottext">charNum :: m Char
</span><a href="#local-6989586621679628516"><span class="hs-identifier hs-var hs-var">charNum</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Char
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Char) -&gt; m Int -&gt; m Char
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Int
</span><a href="#local-6989586621679628509"><span class="hs-identifier hs-var">num</span></a></span><span>
</span><span id="line-466"></span><span>    </span><span class="hs-keyword">where</span><span>
</span><span id="line-467"></span><span>      </span><span class="annot"><a href="#local-6989586621679628509"><span class="hs-identifier hs-type">num</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-468"></span><span>      </span><span id="local-6989586621679628509"><span class="annot"><span class="annottext">num :: m Int
</span><a href="#local-6989586621679628509"><span class="hs-identifier hs-var hs-var">num</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; m Int
</span><a href="#local-6989586621679628508"><span class="hs-identifier hs-var">bounded</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">10</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628507"><span class="hs-identifier hs-var">maxchar</span></a></span><span>
</span><span id="line-469"></span><span>        </span><span class="annot"><span class="annottext">m Int -&gt; m Int -&gt; m Int
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'o'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Int -&gt; m Int
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; m Int
</span><a href="#local-6989586621679628508"><span class="hs-identifier hs-var">bounded</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628507"><span class="hs-identifier hs-var">maxchar</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-470"></span><span>        </span><span class="annot"><span class="annottext">m Int -&gt; m Int -&gt; m Int
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'x'</span></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m Int -&gt; m Int
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; m Int
</span><a href="#local-6989586621679628508"><span class="hs-identifier hs-var">bounded</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628507"><span class="hs-identifier hs-var">maxchar</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-471"></span><span>      </span><span id="local-6989586621679628507"><span class="annot"><span class="annottext">maxchar :: Int
</span><a href="#local-6989586621679628507"><span class="hs-identifier hs-var hs-var">maxchar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#maxBound"><span class="hs-identifier hs-var">maxBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">)</span><span>
</span><span id="line-472"></span><span>
</span><span id="line-473"></span><span>  </span><span class="annot"><a href="#local-6989586621679628508"><span class="hs-identifier hs-type">bounded</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-474"></span><span>  </span><span id="local-6989586621679628508"><span class="annot"><span class="annottext">bounded :: Int -&gt; Int -&gt; m Int
</span><a href="#local-6989586621679628508"><span class="hs-identifier hs-var hs-var">bounded</span></a></span></span><span> </span><span id="local-6989586621679628502"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628502"><span class="hs-identifier hs-var">base</span></a></span></span><span> </span><span id="local-6989586621679628501"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628501"><span class="hs-identifier hs-var">bnd</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Char -&gt; Int) -&gt; Int -&gt; String -&gt; Int
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier hs-var">foldl'</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679628499"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628499"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679628498"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628498"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628502"><span class="hs-identifier hs-var">base</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628499"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Int
</span><a href="../../base/src/Data.Char.html#digitToInt"><span class="hs-identifier hs-var">digitToInt</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628498"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-475"></span><span>                 </span><span class="annot"><span class="annottext">(String -&gt; Int) -&gt; m String -&gt; m Int
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; [Int] -&gt; m String
</span><a href="#local-6989586621679628495"><span class="hs-identifier hs-var">bounded'</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; [m Char] -&gt; [m Char]
forall a. Int -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#take"><span class="hs-identifier hs-var">take</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628502"><span class="hs-identifier hs-var">base</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628493"><span class="hs-identifier hs-var">thedigits</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; Int) -&gt; String -&gt; [Int]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Int
</span><a href="../../base/src/Data.Char.html#digitToInt"><span class="hs-identifier hs-var">digitToInt</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; [Int]) -&gt; String -&gt; [Int]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; (Int -&gt; Char) -&gt; Int -&gt; String -&gt; String
forall a.
(Integral a, Show a) =&gt;
a -&gt; (Int -&gt; Char) -&gt; a -&gt; String -&gt; String
</span><a href="../../base/src/Numeric.html#showIntAtBase"><span class="hs-identifier hs-var">showIntAtBase</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628502"><span class="hs-identifier hs-var">base</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Char
</span><a href="../../base/src/GHC.Show.html#intToDigit"><span class="hs-identifier hs-var">intToDigit</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628501"><span class="hs-identifier hs-var">bnd</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-476"></span><span>    </span><span class="hs-keyword">where</span><span>
</span><span id="line-477"></span><span>      </span><span class="annot"><a href="#local-6989586621679628493"><span class="hs-identifier hs-type">thedigits</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">]</span><span>
</span><span id="line-478"></span><span>      </span><span id="local-6989586621679628493"><span class="annot"><span class="annottext">thedigits :: [m Char]
</span><a href="#local-6989586621679628493"><span class="hs-identifier hs-var hs-var">thedigits</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; m Char) -&gt; String -&gt; [m Char]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'0'</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'9'</span></span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; [m Char] -&gt; [m Char]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; m Char) -&gt; [String] -&gt; [m Char]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m Char
forall (m :: * -&gt; *). CharParsing m =&gt; String -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#oneOf"><span class="hs-identifier hs-var">P.oneOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[String] -&gt; [String]
forall a. [[a]] -&gt; [[a]]
</span><a href="../../base/src/Data.OldList.html#transpose"><span class="hs-identifier hs-var">transpose</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">[</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'A'</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'F'</span></span><span class="hs-special">]</span><span class="hs-special">,</span><span class="hs-special">[</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'a'</span></span><span class="hs-glyph">..</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'f'</span></span><span class="hs-special">]</span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-479"></span><span>
</span><span id="line-480"></span><span>      </span><span id="local-6989586621679629384"><span class="annot"><a href="#local-6989586621679628491"><span class="hs-identifier hs-type">toomuch</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679629384"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-481"></span><span>      </span><span id="local-6989586621679628491"><span class="annot"><span class="annottext">toomuch :: forall a. m a
</span><a href="#local-6989586621679628491"><span class="hs-identifier hs-var hs-var">toomuch</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">P.unexpected</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;out-of-range numeric escape sequence&quot;</span></span><span>
</span><span id="line-482"></span><span>
</span><span id="line-483"></span><span>      </span><span class="annot"><a href="#local-6989586621679628495"><span class="hs-identifier hs-type">bounded'</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679628489"><span class="hs-identifier hs-type">bounded''</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">]</span><span>
</span><span id="line-484"></span><span>      </span><span id="local-6989586621679628495"><span class="annot"><span class="annottext">bounded' :: [m Char] -&gt; [Int] -&gt; m String
</span><a href="#local-6989586621679628495"><span class="hs-identifier hs-var hs-var">bounded'</span></a></span></span><span> </span><span id="local-6989586621679628488"><span class="annot"><span class="annottext">dps :: [m Char]
</span><a href="#local-6989586621679628488"><span class="hs-identifier hs-var">dps</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span id="local-6989586621679628487"><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628487"><span class="hs-identifier hs-var">zero</span></a></span></span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span class="annot"><span class="annottext">[m Char]
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679628486"><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628486"><span class="hs-identifier hs-var">bds</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipSome"><span class="hs-identifier hs-var">P.skipSome</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628487"><span class="hs-identifier hs-var">zero</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">String -&gt; m () -&gt; m String
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">P.notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[m Char] -&gt; m Char
forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var">P.choice</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628488"><span class="hs-identifier hs-var">dps</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; [Int] -&gt; m String
</span><a href="#local-6989586621679628489"><span class="hs-identifier hs-var">bounded''</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628488"><span class="hs-identifier hs-var">dps</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628486"><span class="hs-identifier hs-var">bds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-485"></span><span>                              </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; [Int] -&gt; m String
</span><a href="#local-6989586621679628489"><span class="hs-identifier hs-var">bounded''</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628488"><span class="hs-identifier hs-var">dps</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628486"><span class="hs-identifier hs-var">bds</span></a></span><span>
</span><span id="line-486"></span><span>      </span><span class="annot"><a href="#local-6989586621679628495"><span class="hs-identifier hs-var">bounded'</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>           </span><span class="annot"><span class="annottext">[Int]
</span><span class="hs-identifier">_</span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;bounded called with base 0&quot;</span></span><span>
</span><span id="line-487"></span><span>      </span><span id="local-6989586621679628489"><span class="annot"><span class="annottext">bounded'' :: [m Char] -&gt; [Int] -&gt; m String
</span><a href="#local-6989586621679628489"><span class="hs-identifier hs-var hs-var">bounded''</span></a></span></span><span> </span><span id="local-6989586621679628483"><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628483"><span class="hs-identifier hs-var">dps</span></a></span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">String -&gt; m () -&gt; m String
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">P.notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[m Char] -&gt; m Char
forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var">P.choice</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628483"><span class="hs-identifier hs-var">dps</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m String
forall a. m a
</span><a href="#local-6989586621679628491"><span class="hs-identifier hs-var">toomuch</span></a></span><span>
</span><span id="line-488"></span><span>      </span><span class="annot"><a href="#local-6989586621679628489"><span class="hs-identifier hs-var">bounded''</span></a></span><span> </span><span id="local-6989586621679628482"><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628482"><span class="hs-identifier hs-var">dps</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679628481"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628481"><span class="hs-identifier hs-var">bd</span></a></span></span><span> </span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span> </span><span id="local-6989586621679628480"><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628480"><span class="hs-identifier hs-var">bds</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span class="annot"><a href="#local-6989586621679628479"><span class="hs-identifier hs-type">anyd</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-489"></span><span>                                     </span><span id="local-6989586621679628479"><span class="annot"><span class="annottext">anyd :: m Char
</span><a href="#local-6989586621679628479"><span class="hs-identifier hs-var hs-var">anyd</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; m Char
forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var">P.choice</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628482"><span class="hs-identifier hs-var">dps</span></a></span><span>
</span><span id="line-490"></span><span>
</span><span id="line-491"></span><span>                                     </span><span class="annot"><a href="#local-6989586621679628478"><span class="hs-identifier hs-type">nomore</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-492"></span><span>                                     </span><span id="local-6989586621679628478"><span class="annot"><span class="annottext">nomore :: m ()
</span><a href="#local-6989586621679628478"><span class="hs-identifier hs-var hs-var">nomore</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m Char -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">P.notFollowedBy</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628479"><span class="hs-identifier hs-var">anyd</span></a></span><span> </span><span class="annot"><span class="annottext">m () -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall a. m a
</span><a href="#local-6989586621679628491"><span class="hs-identifier hs-var">toomuch</span></a></span><span>
</span><span id="line-493"></span><span>
</span><span id="line-494"></span><span>                                     </span><span class="hs-special">(</span><span id="local-6989586621679628477"><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628477"><span class="hs-identifier hs-var">low</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679628476"><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628476"><span class="hs-identifier hs-var">ex</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679628475"><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628475"><span class="hs-identifier hs-var">high</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Int -&gt; [m Char] -&gt; ([m Char], [m Char])
forall a. Int -&gt; [a] -&gt; ([a], [a])
</span><a href="../../base/src/GHC.List.html#splitAt"><span class="hs-identifier hs-var">splitAt</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679628481"><span class="hs-identifier hs-var">bd</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628482"><span class="hs-identifier hs-var">dps</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-495"></span><span>                                        </span><span class="hs-special">(</span><span id="local-6989586621679628473"><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628473"><span class="hs-identifier hs-var">low'</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679628472"><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628472"><span class="hs-identifier hs-var">ex'</span></a></span></span><span> </span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span> </span><span id="local-6989586621679628471"><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628471"><span class="hs-identifier hs-var">high'</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628473"><span class="hs-identifier hs-var">low'</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628472"><span class="hs-identifier hs-var">ex'</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628471"><span class="hs-identifier hs-var">high'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-496"></span><span>                                        </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[m Char]
</span><span class="hs-identifier">_</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ([m Char], m Char, [m Char])
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;escapeCode: Logic error&quot;</span></span><span>
</span><span id="line-497"></span><span>                                  </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-glyph">:</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; String -&gt; String) -&gt; m Char -&gt; m (String -&gt; String)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; m Char
forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var">P.choice</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628477"><span class="hs-identifier hs-var">low</span></a></span><span> </span><span class="annot"><span class="annottext">m (String -&gt; String) -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; m Char -&gt; m String
forall {t} {f :: * -&gt; *} {a}.
(Ord t, Num t, Alternative f) =&gt;
t -&gt; f a -&gt; f [a]
</span><a href="#local-6989586621679628470"><span class="hs-identifier hs-var">atMost</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628480"><span class="hs-identifier hs-var">bds</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628479"><span class="hs-identifier hs-var">anyd</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m String -&gt; m () -&gt; m String
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628478"><span class="hs-identifier hs-var">nomore</span></a></span><span>
</span><span id="line-498"></span><span>                                     </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-glyph">:</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; String -&gt; String) -&gt; m Char -&gt; m (String -&gt; String)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628476"><span class="hs-identifier hs-var">ex</span></a></span><span> </span><span class="annot"><span class="annottext">m (String -&gt; String) -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">String -&gt; m () -&gt; m String
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628478"><span class="hs-identifier hs-var">nomore</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; [Int] -&gt; m String
</span><a href="#local-6989586621679628489"><span class="hs-identifier hs-var">bounded''</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628482"><span class="hs-identifier hs-var">dps</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628480"><span class="hs-identifier hs-var">bds</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-499"></span><span>                                     </span><span class="annot"><span class="annottext">m String -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool
</span><span class="hs-identifier hs-var">not</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int] -&gt; Bool
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#null"><span class="hs-identifier hs-var">null</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628480"><span class="hs-identifier hs-var">bds</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-500"></span><span>                                            </span><span class="hs-keyword">then</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">:</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; String -&gt; String) -&gt; m Char -&gt; m (String -&gt; String)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; m Char
forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var">P.choice</span></a></span><span> </span><span class="annot"><span class="annottext">[m Char]
</span><a href="#local-6989586621679628475"><span class="hs-identifier hs-var">high</span></a></span><span> </span><span class="annot"><span class="annottext">m (String -&gt; String) -&gt; m String -&gt; m String
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; m Char -&gt; m String
forall {t} {f :: * -&gt; *} {a}.
(Ord t, Num t, Alternative f) =&gt;
t -&gt; f a -&gt; f [a]
</span><a href="#local-6989586621679628470"><span class="hs-identifier hs-var">atMost</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Int] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[Int]
</span><a href="#local-6989586621679628480"><span class="hs-identifier hs-var">bds</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Char
</span><a href="#local-6989586621679628479"><span class="hs-identifier hs-var">anyd</span></a></span><span> </span><span class="annot"><span class="annottext">m String -&gt; m () -&gt; m String
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
</span><a href="#local-6989586621679628478"><span class="hs-identifier hs-var">nomore</span></a></span><span>
</span><span id="line-501"></span><span>                                            </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">m String
forall (f :: * -&gt; *) a. Alternative f =&gt; f a
</span><a href="../../base/src/GHC.Base.html#empty"><span class="hs-identifier hs-var">empty</span></a></span><span>
</span><span id="line-502"></span><span>      </span><span id="local-6989586621679628470"><span class="annot"><span class="annottext">atMost :: t -&gt; f a -&gt; f [a]
</span><a href="#local-6989586621679628470"><span class="hs-identifier hs-var hs-var">atMost</span></a></span></span><span> </span><span id="local-6989586621679628454"><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679628454"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679628453"><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679628453"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679628454"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">0</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; f [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-503"></span><span>                 </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-glyph">:</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(a -&gt; [a] -&gt; [a]) -&gt; f a -&gt; f ([a] -&gt; [a])
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679628453"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">f ([a] -&gt; [a]) -&gt; f [a] -&gt; f [a]
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; f a -&gt; f [a]
</span><a href="#local-6989586621679628470"><span class="hs-identifier hs-var">atMost</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">t
</span><a href="#local-6989586621679628454"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">t -&gt; t -&gt; t
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">t
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">f a
</span><a href="#local-6989586621679628453"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">f [a] -&gt; f [a] -&gt; f [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; f [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-504"></span><span>
</span><span id="line-505"></span><span>  </span><span class="annot"><a href="#local-6989586621679628517"><span class="hs-identifier hs-type">charEsc</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-506"></span><span>  </span><span id="local-6989586621679628517"><span class="annot"><span class="annottext">charEsc :: m Char
</span><a href="#local-6989586621679628517"><span class="hs-identifier hs-var hs-var">charEsc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; m Char
forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var">P.choice</span></a></span><span> </span><span class="annot"><span class="annottext">([m Char] -&gt; m Char) -&gt; [m Char] -&gt; m Char
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">(Char, Char) -&gt; m Char
forall {f :: * -&gt; *} {a}. CharParsing f =&gt; (Char, a) -&gt; f a
</span><a href="#local-6989586621679628451"><span class="hs-identifier hs-var">parseEsc</span></a></span><span> </span><span class="annot"><span class="annottext">((Char, Char) -&gt; m Char) -&gt; [(Char, Char)] -&gt; [m Char]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[(Char, Char)]
</span><a href="#local-6989586621679628450"><span class="hs-identifier hs-var">escMap</span></a></span><span>
</span><span id="line-507"></span><span>
</span><span id="line-508"></span><span>  </span><span id="local-6989586621679628451"><span class="annot"><span class="annottext">parseEsc :: (Char, a) -&gt; f a
</span><a href="#local-6989586621679628451"><span class="hs-identifier hs-var hs-var">parseEsc</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679628442"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628442"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679628441"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679628441"><span class="hs-identifier hs-var">code</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679628441"><span class="hs-identifier hs-var">code</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; f Char -&gt; f a
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; f Char
forall (m :: * -&gt; *). CharParsing m =&gt; Char -&gt; m Char
</span><a href="Distribution.Compat.CharParsing.html#char"><span class="hs-identifier hs-var">P.char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679628442"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-509"></span><span>  </span><span id="local-6989586621679628450"><span class="annot"><span class="annottext">escMap :: [(Char, Char)]
</span><a href="#local-6989586621679628450"><span class="hs-identifier hs-var hs-var">escMap</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; [(Char, Char)]
forall a b. [a] -&gt; [b] -&gt; [(a, b)]
</span><a href="../../base/src/GHC.List.html#zip"><span class="hs-identifier hs-var">zip</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;abfnrtv\\\&quot;\'&quot;</span></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;\a\b\f\n\r\t\v\\\&quot;\'&quot;</span></span><span>
</span><span id="line-510"></span><span>
</span><span id="line-511"></span><span>  </span><span class="annot"><a href="#local-6989586621679628515"><span class="hs-identifier hs-type">charAscii</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679628616"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span>
</span><span id="line-512"></span><span>  </span><span id="local-6989586621679628515"><span class="annot"><span class="annottext">charAscii :: m Char
</span><a href="#local-6989586621679628515"><span class="hs-identifier hs-var hs-var">charAscii</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m Char] -&gt; m Char
forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var">P.choice</span></a></span><span> </span><span class="annot"><span class="annottext">([m Char] -&gt; m Char) -&gt; [m Char] -&gt; m Char
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">(String, Char) -&gt; m Char
forall {m :: * -&gt; *} {a}. CharParsing m =&gt; (String, a) -&gt; m a
</span><a href="#local-6989586621679628440"><span class="hs-identifier hs-var">parseAscii</span></a></span><span> </span><span class="annot"><span class="annottext">((String, Char) -&gt; m Char) -&gt; [(String, Char)] -&gt; [m Char]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[(String, Char)]
</span><a href="#local-6989586621679628439"><span class="hs-identifier hs-var">asciiMap</span></a></span><span>
</span><span id="line-513"></span><span>
</span><span id="line-514"></span><span>  </span><span id="local-6989586621679628440"><span class="annot"><span class="annottext">parseAscii :: (String, a) -&gt; m a
</span><a href="#local-6989586621679628440"><span class="hs-identifier hs-var hs-var">parseAscii</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679628430"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628430"><span class="hs-identifier hs-var">asc</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679628429"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679628429"><span class="hs-identifier hs-var">code</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">P.try</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; m a) -&gt; m a -&gt; m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679628429"><span class="hs-identifier hs-var">code</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; m String -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m String
forall (m :: * -&gt; *). CharParsing m =&gt; String -&gt; m String
</span><a href="Distribution.Compat.CharParsing.html#string"><span class="hs-identifier hs-var">P.string</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628430"><span class="hs-identifier hs-var">asc</span></a></span><span>
</span><span id="line-515"></span><span>  </span><span id="local-6989586621679628439"><span class="annot"><span class="annottext">asciiMap :: [(String, Char)]
</span><a href="#local-6989586621679628439"><span class="hs-identifier hs-var hs-var">asciiMap</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String -&gt; [(String, Char)]
forall a b. [a] -&gt; [b] -&gt; [(a, b)]
</span><a href="../../base/src/GHC.List.html#zip"><span class="hs-identifier hs-var">zip</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679628428"><span class="hs-identifier hs-var">ascii3codes</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; [String] -&gt; [String]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679628427"><span class="hs-identifier hs-var">ascii2codes</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628426"><span class="hs-identifier hs-var">ascii3</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679628425"><span class="hs-identifier hs-var">ascii2</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-516"></span><span>  </span><span class="annot"><a href="#local-6989586621679628427"><span class="hs-identifier hs-type">ascii2codes</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679628428"><span class="hs-identifier hs-type">ascii3codes</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-517"></span><span>  </span><span id="local-6989586621679628427"><span class="annot"><span class="annottext">ascii2codes :: [String]
</span><a href="#local-6989586621679628427"><span class="hs-identifier hs-var hs-var">ascii2codes</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;BS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;HT&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;LF&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;VT&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;FF&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CR&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SO&quot;</span></span><span>
</span><span id="line-518"></span><span>                </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SI&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;EM&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;FS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;RS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;US&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SP&quot;</span></span><span class="hs-special">]</span><span>
</span><span id="line-519"></span><span>  </span><span id="local-6989586621679628428"><span class="annot"><span class="annottext">ascii3codes :: [String]
</span><a href="#local-6989586621679628428"><span class="hs-identifier hs-var hs-var">ascii3codes</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;NUL&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SOH&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;STX&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ETX&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;EOT&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ENQ&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ACK&quot;</span></span><span>
</span><span id="line-520"></span><span>                </span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;BEL&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DLE&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC1&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC2&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC3&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC4&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;NAK&quot;</span></span><span>
</span><span id="line-521"></span><span>                </span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SYN&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ETB&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CAN&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SUB&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ESC&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DEL&quot;</span></span><span class="hs-special">]</span><span>
</span><span id="line-522"></span><span>  </span><span class="annot"><a href="#local-6989586621679628425"><span class="hs-identifier hs-type">ascii2</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679628426"><span class="hs-identifier hs-type">ascii3</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-523"></span><span>  </span><span id="local-6989586621679628425"><span class="annot"><span class="annottext">ascii2 :: String
</span><a href="#local-6989586621679628425"><span class="hs-identifier hs-var hs-var">ascii2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;\BS\HT\LF\VT\FF\CR\SO\SI\EM\FS\GS\RS\US\SP&quot;</span></span><span>
</span><span id="line-524"></span><span>  </span><span id="local-6989586621679628426"><span class="annot"><span class="annottext">ascii3 :: String
</span><a href="#local-6989586621679628426"><span class="hs-identifier hs-var hs-var">ascii3</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;\NUL\SOH\STX\ETX\EOT\ENQ\ACK\BEL\DLE\DC1\DC2\DC3\DC4\NAK\SYN\ETB\CAN\SUB\ESC\DEL&quot;</span></span><span>
</span><span id="line-525"></span></pre></body></html>